assignable_values 0.1.0

data/.gitignore

@@ -0,0 +1,8 @@
+doc
+pkg
+*.gem
+.idea
+spec/app_root/log/*
+Gemfile.lock
+
+

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,99 @@
+# assignable_values - Enums on vitamins
+
+`assignable_values` lets you restrict the values that can be assigned to attributes or associations of ActiveRecord models. You can think of it as enums where the list of allowed values is generated at runtime and the value is checked during validation.
+
+We carefully enhanced the cure enum functionality with small tweaks that are useful for web forms, internationalized applications and common authorization patterns.
+
+## Restricting attributes
+
+The basic usage to restrict the values assignable to strings, integers, etc. is this:
+
+    class Song < ActiveRecord::Base
+      assignable_values_for :genre do
+        ['pop', 'rock', 'electronic']
+      end
+    end
+
+The assigned value is checked during validation:
+
+    Song.new(:genre => 'rock').valid?     # => true
+    Song.new(:genre => 'elephant').valid? # => false
+
+The validation error message is the same as the one from `validates_inclusion_of` (`errors.messages.inclusion` in your I18n dictionary).
+
+### How assignable values are generated
+
+The list of assignable values is generated at runtime. Since the given block is evaluated on the record instance, so you can refer to other methods:
+
+    class Song < ActiveRecord::Base
+
+      validates_numericality_of :year
+
+      assignable_values_for :genre do
+        genres = []
+        genres << 'jazz' if year > 1900
+        genres << 'rock' if year > 1960
+        genres
+      end
+
+    end
+
+### Obtaining lists
+
+You can ask a record for a list of values that can be assigned to attribute:
+
+    song.assignable_genres # => ['pop', 'rock', 'electronic']
+
+This is useful for populating &lt;select&gt; tags in web forms:
+
+    form.select :genre, form.object.assignable_genres
+
+### Human labels
+
+You will often want to present internal values in a humanized form. E.g. `"pop"` should be presented as `"Pop music"`.
+
+You can define human labels in your I18n dictionary:
+
+    en:
+      assignable_values:
+        song:
+          genre:
+            pop: 'Pop music'
+            rock: 'Rock music'
+            electronic: 'Electronic music'
+            
+When obtaining a list of assignable values, each value will have a method `#human` that returns the translation:
+
+    song.assignable_genres.first       # => 'pop'
+    song.assignable_genres.first.human # => 'Pop music'
+
+You can populate a &lt;select&gt; tag with pairs of internal values and human labels like this:
+
+    form.collection_select :genre, form.object.assignable_genres, :to_s, :human
+
+## Restricting belongs_to associations
+
+### No caching
+
+## Defining default values
+
+## Obtaining assignable values from a delegate
+
+Text here.
+
+## Previously saved values
+
+- Always valid
+- Are listed
+
+## Installation
+
+Text here.
+
+## Development
+
+Text here.
+
+## Credits
+
+Text here.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+desc 'Default: Run all specs.'
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new do |t|
+#  t.spec_files = FileList['spec/**/*_spec.rb']
+end

data/assignable_values.gemspec

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "assignable_values/version"
+
+Gem::Specification.new do |s|
+  s.name = 'assignable_values'
+  s.version = AssignableValues::VERSION
+  s.authors = ["Henning Koch"]
+  s.email = 'henning.koch@makandra.de'
+  s.homepage = 'https://github.com/makandra/assignable_values'
+  s.summary = 'Restrict the values assignable to ActiveRecord attributes or associations. Or enums on steroids.'
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('rails', '~>3.1')
+  s.add_development_dependency('rspec', '~>2.8')
+  s.add_development_dependency('rspec-rails', '~>2.8')
+  s.add_development_dependency('sqlite3')
+end

data/lib/assignable_values.rb

@@ -0,0 +1,6 @@
+require 'assignable_values/errors'
+require 'assignable_values/active_record'
+require 'assignable_values/active_record/restriction/base'
+require 'assignable_values/active_record/restriction/belongs_to_association'
+require 'assignable_values/active_record/restriction/scalar_attribute'
+

data/lib/assignable_values/active_record.rb

@@ -0,0 +1,25 @@
+module AssignableValues
+  module ActiveRecord
+
+    private
+
+    def assignable_values_for(property, options = {}, &values)
+      restriction_type = belongs_to_association?(property) ? Restriction::BelongsToAssociation : Restriction::ScalarAttribute
+      restriction_type.new(self, property, options, &values)
+    end
+
+    #def authorize_values_for(property, options = {})
+    #  method_defined?(:power) or attr_accessor :power
+    #  assignable_values_for property, options.merge(:through => :power)
+    #end
+
+    def belongs_to_association?(property)
+      reflection = reflect_on_association(property)
+      reflection && reflection.macro == :belongs_to
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:extend, AssignableValues::ActiveRecord)
+

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

@@ -0,0 +1,152 @@
+module AssignableValues
+  module ActiveRecord
+    module Restriction
+      class Base
+
+        attr_reader :model, :property, :options, :values, :default
+
+        def initialize(model, property, options, &values)
+          @model = model
+          @property = property
+          @options = options
+          @values = values
+          ensure_values_given
+          setup_default if default?
+          define_assignable_values_method
+          setup_validation
+        end
+
+        def validate_record(record)
+          value = current_value(record)
+          unless allow_blank? && value.blank?
+            begin
+              assignable_values = assignable_values(record)
+              assignable_values.include?(value) or record.errors.add(property, I18n.t('errors.messages.inclusion'))
+            rescue DelegateUnavailable
+              # if the delegate is unavailable, the validation is skipped
+            end
+          end
+        end
+
+        def assignable_values(record)
+          assignable_values = []
+          old_value = previously_saved_value(record)
+          assignable_values << old_value if old_value.present?
+          assignable_values |= raw_assignable_values(record)
+          assignable_values = decorate_values(assignable_values)
+          assignable_values
+        end
+
+        def set_default(record)
+          if record.new_record? && record.send(property).nil?
+            default_value = default
+            default_value = record.instance_eval(&default_value) if default_value.is_a?(Proc)
+            record.send("#{property}=", default_value)
+          end
+          true
+        end
+
+        def humanize_string_value(value)
+          I18n.t("assignable_values.#{model.name.underscore}.#{property}.#{value}", :default => value.humanize)
+        end
+
+        private
+
+        def current_value(record)
+          record.send(property)
+        end
+
+        def previously_saved_value(record)
+          nil
+        end
+
+        def decorate_values(values)
+          values
+        end
+
+        def delegate?
+          @options.has_key?(:through)
+        end
+
+        def default?
+          @options.has_key?(:default)
+        end
+
+        def allow_blank?
+          @options[:allow_blank]
+        end
+
+        def delegate_definition
+          options[:through]
+        end
+
+        def enhance_model(&block)
+          @model.class_eval(&block)
+        end
+
+        def setup_default
+          @default = options[:default]
+          restriction = self
+          enhance_model do
+            set_default_method = "set_default_#{restriction.property}"
+            define_method set_default_method do
+              restriction.set_default(self)
+            end
+            after_initialize set_default_method
+          end
+        end
+
+        def setup_validation
+          restriction = self
+          enhance_model do
+            validate_method = "validate_#{restriction.property}_assignable"
+            define_method validate_method do
+              restriction.validate_record(self)
+            end
+            validate validate_method
+          end
+        end
+
+        def define_assignable_values_method
+          restriction = self
+          enhance_model do
+            assignable_values_method = "assignable_#{restriction.property.to_s.pluralize}"
+            define_method assignable_values_method do
+              restriction.assignable_values(self)
+            end
+          end
+        end
+
+        def raw_assignable_values(record)
+          if delegate?
+            assignable_values_from_delegate(record)
+          else
+            record.instance_eval(&@values)
+          end.to_a
+        end
+
+        def delegate(record)
+          case delegate_definition
+          when Symbol then record.send(delegate_definition)
+          when Proc then record.instance_eval(&delegate_definition)
+          else raise "Illegal delegate definition: #{delegate_definition.inspect}"
+          end
+        end
+
+        def assignable_values_from_delegate(record)
+          delegate = delegate(record)
+          delegate.present? or raise DelegateUnavailable, "Cannot query a nil delegate for assignable values"
+          delegate_query_method = "assignable_#{model.name.underscore}_#{property.to_s.pluralize}"
+          args = delegate.method(delegate_query_method).arity == 1 ? [record] : []
+          delegate.send(delegate_query_method, *args)
+        end
+
+        def ensure_values_given
+          @values or @options[:through] or raise NoValuesGiven, 'You must supply the list of assignable values by either a block or :through option'
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,41 @@
+module AssignableValues
+  module ActiveRecord
+    module Restriction
+      class BelongsToAssociation < Base
+
+        private
+
+        def association_class
+          model.reflect_on_association(property).klass
+        end
+
+        def association_id_method
+          "#{property}_id"
+        end
+
+        def association_id(record)
+          record.send(association_id_method)
+        end
+
+        def previously_saved_value(record)
+          if old_id = record.send("#{association_id_method}_was")
+            if old_id == association_id(record)
+              current_value(record) # no need to query the database if nothing changed
+            else
+              association_class.find_by_id(old_id)
+            end
+          end
+        end
+
+        def current_value(record)
+          value = record.send(property)
+          value = record.send(property, true) if (value && value.id) != association_id(record)
+          value
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,28 @@
+module AssignableValues
+  module ActiveRecord
+    module Restriction
+      class ScalarAttribute < Base
+
+        private
+
+        def decorate_values(values)
+          restriction = self
+          values.collect do |value|
+            if value.is_a?(String)
+              value = value.dup
+              value.singleton_class.send(:define_method, :human) do
+                restriction.humanize_string_value(value)
+              end
+            end
+            value
+          end
+        end
+
+        def previously_saved_value(record)
+          record.send("#{property}_was")
+        end
+
+      end
+    end
+  end
+end

data/lib/assignable_values/errors.rb

@@ -0,0 +1,5 @@
+module AssignableValues
+  class Error < StandardError; end
+  class DelegateUnavailable < Error; end
+  class NoValuesGiven < Error; end
+end

data/lib/assignable_values/version.rb

@@ -0,0 +1,3 @@
+module AssignableValues
+  VERSION = '0.1.0'
+end

data/spec/app_root/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/**/*

data/spec/app_root/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/spec/app_root/app/models/artist.rb

@@ -0,0 +1,5 @@
+class Artist < ActiveRecord::Base
+
+  has_many :songs
+
+end

data/spec/app_root/app/models/song.rb

@@ -0,0 +1,5 @@
+class Song < ActiveRecord::Base
+
+  belongs_to :artist
+
+end

data/spec/app_root/config/application.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+# If you have a Gemfile, require the gems listed there, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(:default, Rails.env) if defined?(Bundler)
+
+module AssignableValuesSpecApp
+  class Application < Rails::Application
+    config.encoding = "utf-8"
+
+    config.cache_classes = true
+    config.whiny_nils = true
+
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    config.action_dispatch.show_exceptions = false
+
+    config.action_controller.allow_forgery_protection    = false
+
+    config.action_mailer.delivery_method = :test
+
+    config.active_support.deprecation = :stderr
+
+    config.root = File.expand_path('../..', __FILE__)
+
+    # railties.plugins << Rails::Plugin.new(File.expand_path('../../../../..', __FILE__))
+  end
+end

data/spec/app_root/config/boot.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+
+# Set up gems listed in the Gemfile.
+gemfile = File.expand_path('../../Gemfile', __FILE__)
+begin
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+rescue Bundler::GemNotFound => e
+  STDERR.puts e.message
+  STDERR.puts "Try running `bundle install`."
+  exit!
+end if File.exist?(gemfile)

data/spec/app_root/config/database.yml

@@ -0,0 +1,4 @@
+in_memory:
+  adapter: sqlite3
+  database: ":memory:"
+  verbosity: quiet

data/spec/app_root/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+AssignableValuesSpecApp::Application.initialize!

data/spec/app_root/config/environments/test.rb

@@ -0,0 +1,35 @@
+AssignableValuesSpecApp::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # The test environment is used exclusively to run your application's
+  # test suite.  You never need to work with it otherwise.  Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs.  Don't rely on the data there!
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Raise exceptions instead of rendering exception templates
+  config.action_dispatch.show_exceptions = false
+
+  # Disable request forgery protection in test environment
+  config.action_controller.allow_forgery_protection    = false
+
+  # Tell Action Mailer not to deliver emails to the real world.
+  # The :test delivery method accumulates sent emails in the
+  # ActionMailer::Base.deliveries array.
+  config.action_mailer.delivery_method = :test
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper,
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Print deprecation notices to the stderr
+  config.active_support.deprecation = :stderr
+end

data/spec/app_root/config/initializers/backtrace_silencers.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
+# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
+
+# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
+# Rails.backtrace_cleaner.remove_silencers!

data/spec/app_root/config/initializers/inflections.rb

@@ -0,0 +1,10 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new inflection rules using the following format
+# (all these examples are active by default):
+# ActiveSupport::Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end

data/spec/app_root/config/initializers/mime_types.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file.
+
+# Add new mime types for use in respond_to blocks:
+# Mime::Type.register "text/richtext", :rtf
+# Mime::Type.register_alias "text/html", :iphone

data/spec/app_root/config/initializers/secret_token.rb

@@ -0,0 +1,7 @@
+# Be sure to restart your server when you modify this file.
+
+# Your secret key for verifying the integrity of signed cookies.
+# If you change this key, all old signed cookies will become invalid!
+# Make sure the secret is at least 30 characters and all random,
+# no regular words or you'll be exposed to dictionary attacks.
+AssignableValuesSpecApp::Application.config.secret_token = 'cb014a08a45243e7143f31e04774c342c1fba329fd594ae1a480d8283b1a851f425dc08044311fb4be6d000b6e6681de7c76d19148419a5ffa0a9f84556d3b33'

data/spec/app_root/config/initializers/session_store.rb

@@ -0,0 +1,8 @@
+# Be sure to restart your server when you modify this file.
+
+AssignableValuesSpecApp::Application.config.session_store :cookie_store, :key => '_app_root_session'
+
+# Use the database for sessions instead of the cookie-based default,
+# which shouldn't be used to store highly confidential information
+# (create the session table with "rails generate session_migration")
+# AssignableValuesSpecApp::Application.config.session_store :active_record_store

data/spec/app_root/config/locales/en.yml

@@ -0,0 +1,10 @@
+# Sample localization file for English. Add more files in this directory for other locales.
+# See http://github.com/svenfuchs/rails-i18n/tree/master/rails%2Flocale for starting points.
+
+en:
+  assignable_values:
+    song:
+      genre:
+        pop: 'Pop music'
+        rock: 'Rock music'
+        

data/spec/app_root/config/routes.rb

@@ -0,0 +1,58 @@
+AssignableValuesSpecApp::Application.routes.draw do
+  # The priority is based upon order of creation:
+  # first created -> highest priority.
+
+  # Sample of regular route:
+  #   match 'products/:id' => 'catalog#view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  #   match 'products/:id/purchase' => 'catalog#purchase', :as => :purchase
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # Sample resource route (maps HTTP verbs to controller actions automatically):
+  #   resources :products
+
+  # Sample resource route with options:
+  #   resources :products do
+  #     member do
+  #       get 'short'
+  #       post 'toggle'
+  #     end
+  #
+  #     collection do
+  #       get 'sold'
+  #     end
+  #   end
+
+  # Sample resource route with sub-resources:
+  #   resources :products do
+  #     resources :comments, :sales
+  #     resource :seller
+  #   end
+
+  # Sample resource route with more complex sub-resources
+  #   resources :products do
+  #     resources :comments
+  #     resources :sales do
+  #       get 'recent', :on => :collection
+  #     end
+  #   end
+
+  # Sample resource route within a namespace:
+  #   namespace :admin do
+  #     # Directs /admin/products/* to Admin::ProductsController
+  #     # (app/controllers/admin/products_controller.rb)
+  #     resources :products
+  #   end
+
+  # You can have the root of your site routed with "root"
+  # just remember to delete public/index.html.
+  # root :to => "welcome#index"
+
+  # See how all your routes lay out with "rake routes"
+
+  # This is a legacy wild controller route that's not recommended for RESTful applications.
+  # Note: This route will make all actions in every controller accessible via GET requests.
+  match ':controller(/:action(/:id(.:format)))'
+end

data/spec/app_root/db/migrate/001_create_artists.rb

@@ -0,0 +1,11 @@
+class CreateArtists < ActiveRecord::Migration
+
+  def self.up
+    create_table :artists
+  end
+
+  def self.down
+    drop_table :artists
+  end
+  
+end

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

@@ -0,0 +1,15 @@
+class CreateSongs < ActiveRecord::Migration
+
+  def self.up
+    create_table :songs do |t|
+      t.integer :artist_id
+      t.string :genre
+      t.integer :year
+    end
+  end
+
+  def self.down
+    drop_table :songs
+  end
+
+end

data/spec/app_root/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby1.8
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/assignable_values/active_record_spec.rb

@@ -0,0 +1,385 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe AssignableValues::ActiveRecord do
+
+  def disposable_song_class(&block)
+    @klass = Class.new(Song, &block)
+    @klass.class_eval do
+      def self.name
+        'Song'
+      end
+    end
+    @klass
+  end
+
+  describe '.assignable_values' do
+
+    it 'should raise an error when not called with a block or :through option' do
+      expect do
+        disposable_song_class do
+          assignable_values_for :genre
+        end
+      end.to raise_error(AssignableValues::NoValuesGiven)
+    end
+
+    context 'when validating scalar attributes' do
+
+      context 'without options' do
+
+        before :each do
+          @klass = disposable_song_class do
+            assignable_values_for :genre do
+              %w[pop rock]
+            end
+          end
+        end
+
+        it 'should validate that the attribute is allowed' do
+          @klass.new(:genre => 'pop').should be_valid
+          @klass.new(:genre => 'disallowed value').should_not be_valid
+        end
+
+        it 'should use the same error message as validates_inclusion_of' do
+          record = @klass.new(:genre => 'disallowed value')
+          record.valid?
+          record.errors[:genre].first.should == I18n.t('errors.messages.inclusion')
+          record.errors[:genre].first.should == 'is not included in the list'
+        end
+
+        it 'should not allow nil for the attribute value' do
+          @klass.new(:genre => nil).should_not be_valid
+        end
+
+        it 'should allow a previously saved value even if that value is no longer allowed' do
+          song = @klass.new(:genre => 'disallowed value')
+          song.save!(:validate => false)
+          song.should be_valid
+        end
+
+      end
+
+      context 'if the :allow_blank option is set' do
+
+        before :each do
+          @klass = disposable_song_class do
+            assignable_values_for :genre, :allow_blank => true do
+              %w[pop rock]
+            end
+          end
+        end
+
+        it 'should allow nil for the attribute value' do
+          @klass.new(:genre => nil).should be_valid
+        end
+
+        it 'should allow an empty string as value if the :allow_blank option is set' do
+          @klass.new(:genre => '').should be_valid
+        end
+
+      end
+
+    end
+
+    context 'when validating belongs_to associations' do
+
+      it 'should validate that the association is allowed' do
+        allowed_association = Artist.create!
+        disallowed_association = Artist.create!
+        @klass = disposable_song_class do
+          assignable_values_for :artist do
+            [allowed_association]
+          end
+        end
+        @klass.new(:artist => allowed_association).should be_valid
+        @klass.new(:artist => disallowed_association).should_not be_valid
+      end
+
+      it 'should allow a nil association if the :allow_blank option is set' do
+        @klass = disposable_song_class do
+          assignable_values_for :artist, :allow_blank => true do
+            []
+          end
+        end
+        record = @klass.new
+        record.artist.should be_nil
+        record.should be_valid
+      end
+
+      it 'should allow a previously saved association even if that association is no longer allowed' do
+        allowed_association = Artist.create!
+        disallowed_association = Artist.create!
+        @klass = disposable_song_class
+        record = @klass.create!(:artist => disallowed_association)
+        @klass.class_eval do
+          assignable_values_for :artist do
+            [allowed_association]
+          end
+        end
+        record.should be_valid
+      end
+
+      it "should not load a previously saved association if the association's foreign key hasn't changed" do
+        association = Artist.create!
+        @klass = disposable_song_class do
+          assignable_values_for :artist do
+            [association] # This example doesn't care about what's assignable. We're only interested in behavior up to the validation.
+          end
+        end
+        record = @klass.create!(:artist => association)
+        Artist.should_not_receive(:find_by_id)
+        record.valid?
+      end
+
+      it 'should not fail or allow nil if a previously saved association no longer exists in the database' do
+        allowed_association = Artist.create!
+        disposable_song_class.class_eval do
+          assignable_values_for :artist do
+            [allowed_association]
+          end
+        end
+        record = @klass.new
+        record.stub :artist_id_was => -1
+        record.should_not be_valid
+      end
+
+      it 'should uncache a stale association before validating' do
+        @klass = disposable_song_class do
+          assignable_values_for :artist do
+            [] # This example doesn't care about what's assignable. We're only interested in behavior up to the validation.
+          end
+        end
+        association = Artist.create!
+        record = @klass.new
+        record.stub(:artist => association, :artist_id => -1) # This is a stale association: The associated object's id doesn't match the foreign key. This can happen in Rails 2, not Rails 3.
+        record.should_receive(:artist).ordered.and_return(association)
+        record.should_receive(:artist).ordered.with(true).and_return(association)
+        record.valid?
+      end
+
+      it 'should not uncache a fresh association before validating' do
+        @klass = disposable_song_class do
+          assignable_values_for :artist do
+            [] # This example doesn't care about what's assignable. We're only interested in behavior up to the validation.
+          end
+        end
+        association = Artist.create!
+        record = @klass.new
+        record.stub(:artist => association, :artist_id => association.id) # This is a fresh association: The associated object's id matches the foreign key.
+        record.should_receive(:artist).with(no_args).and_return(association)
+        record.valid?
+      end
+
+    end
+
+    context 'when delegating using the :through option' do
+
+      it 'should obtain allowed values from a method with the given name' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :through => :delegate
+          def delegate
+            OpenStruct.new(:assignable_song_genres => %w[pop rock])
+          end
+        end
+        @klass.new(:genre => 'pop').should be_valid
+        @klass.new(:genre => 'disallowed value').should_not be_valid
+      end
+
+      it 'should be able to delegate to a lambda, which is evaluated in the context of the record instance' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :through => lambda { delegate }
+          def delegate
+            OpenStruct.new(:assignable_song_genres => %w[pop rock])
+          end
+        end
+        @klass.new(:genre => 'pop').should be_valid
+        @klass.new(:genre => 'disallowed value').should_not be_valid
+      end
+
+      it 'should skip the validation if that method returns nil' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :through => :delegate
+          def delegate
+            nil
+          end
+        end
+        @klass.new(:genre => 'pop').should be_valid
+      end
+
+    end
+
+    context 'with :default option' do
+
+      it 'should allow to set a default' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :default => 'pop' do
+            %w[pop rock]
+          end
+        end
+        @klass.new.genre.should == 'pop'
+      end
+
+      it 'should allow to set a default through a lambda' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :default => lambda { 'pop' } do
+            %w[pop rock]
+          end
+        end
+        @klass.new.genre.should == 'pop'
+      end
+
+      it 'should evaluate a lambda default in the context of the record instance' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre, :default => lambda { default_genre } do
+            %w[pop rock]
+          end
+          def default_genre
+            'pop'
+          end
+        end
+        @klass.new.genre.should == 'pop'
+      end
+
+    end
+
+    context 'when generating methods to list assignable values' do
+
+      it 'should generate an instance method returning a list of assignable values' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre do
+            %w[pop rock]
+          end
+        end
+        @klass.new.assignable_genres.should == %w[pop rock]
+      end
+
+      it "should define a method #human on strings in that list, which return up the value's' translation" do
+        @klass = disposable_song_class do
+          assignable_values_for :genre do
+            %w[pop rock]
+          end
+        end
+        @klass.new.assignable_genres.collect(&:human).should == ['Pop music', 'Rock music']
+      end
+
+      it 'should use String#humanize as a default translation' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre do
+            %w[electronic]
+          end
+        end
+        @klass.new.assignable_genres.collect(&:human).should == ['Electronic']
+      end
+
+      it 'should not define a method #human on values that are not strings' do
+        @klass = disposable_song_class 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(:human)
+      end
+
+      it 'should call #to_a on the list of assignable values, allowing ranges and scopes to be passed as allowed value descriptors' do
+        @klass = disposable_song_class do
+          assignable_values_for :year do
+            1999..2001
+          end
+        end
+        @klass.new.assignable_years.should == [1999, 2000, 2001]
+      end
+
+      it 'should evaluate the value block in the context of the record instance' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre do
+            genres
+          end
+          def genres
+            %w[pop rock]
+          end
+        end
+        @klass.new.assignable_genres.should == %w[pop rock]
+      end
+
+      it 'should include a previously saved value, even if is no longer allowed' do
+        @klass = disposable_song_class do
+          assignable_values_for :genre do
+            %w[pop rock]
+          end
+        end
+        record = @klass.new(:genre => 'ballad')
+        record.save!(:validate => false)
+        record.assignable_genres.should =~ %w[pop rock ballad]
+      end
+
+      context 'with :through option' do
+
+        it 'should retrieve assignable values from the given method' do
+          @klass = disposable_song_class do
+            assignable_values_for :genre, :through => :delegate
+            def delegate
+              @delegate ||= 'delegate'
+            end
+          end
+          record = @klass.new
+          record.delegate.should_receive(:assignable_song_genres).and_return %w[pop rock]
+          record.assignable_genres.should == %w[pop rock]
+        end
+
+        it "should pass the record to the given method if the delegate's query method takes an argument" do
+          delegate = Object.new
+          def delegate.assignable_song_genres(record)
+            record_received(record)
+             %w[pop rock]
+          end
+          @klass = disposable_song_class do
+            assignable_values_for :genre, :through => :delegate
+            define_method :delegate do
+              delegate
+            end
+          end
+          record = @klass.new
+          delegate.should_receive(:record_received).with(record)
+          record.assignable_genres.should ==  %w[pop rock]
+        end
+
+        it 'should raise an error if the given method returns nil' do
+          @klass = disposable_song_class do
+            assignable_values_for :genre, :through => :delegate
+            def delegate
+              nil
+            end
+          end
+          expect { @klass.new.assignable_genres }.to raise_error(AssignableValues::DelegateUnavailable)
+        end
+
+      end
+
+    end
+
+  end
+
+  #describe '.authorize_values_for' do
+  #
+  #  it 'should be a shortcut for .assignable_values_for :attribute, :through => :power' do
+  #    @klass = disposable_song_class
+  #    @klass.should_receive(:assignable_values_for).with(:attribute, :option => 'option', :through => :power)
+  #    @klass.class_eval do
+  #      authorize_values_for :attribute, :option => 'option'
+  #    end
+  #  end
+  #
+  #  it 'should generate a getter and setter for a @power field' do
+  #    @klass = disposable_song_class do
+  #      authorize_values_for :attribute
+  #    end
+  #    song = @klass.new
+  #    song.should respond_to(:power)
+  #    song.should respond_to(:power=)
+  #  end
+  #
+  #end
+
+end

data/spec/rcov.opts

@@ -0,0 +1,2 @@
+--exclude "spec/*,gems/*"
+--rails

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$: << File.join(File.dirname(__FILE__), "/../lib" )
+
+# Set the default environment to sqlite3's in_memory database
+ENV['RAILS_ENV'] ||= 'in_memory'
+ENV['RAILS_ROOT'] = 'app_root'
+
+# Load the Rails environment and testing framework
+require "#{File.dirname(__FILE__)}/app_root/config/environment"
+require "#{File.dirname(__FILE__)}/../lib/assignable_values"
+require 'rspec/rails'
+
+# Undo changes to RAILS_ENV
+silence_warnings {RAILS_ENV = ENV['RAILS_ENV']}
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.use_instantiated_fixtures  = false
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification 
+name: assignable_values
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Henning Koch
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-20 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 1
+        version: "3.1"
+  name: rails
+  version_requirements: *id001
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 8
+        version: "2.8"
+  name: rspec
+  version_requirements: *id002
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 2
+        - 8
+        version: "2.8"
+  name: rspec-rails
+  version_requirements: *id003
+  type: :development
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: sqlite3
+  version_requirements: *id004
+  type: :development
+description: Restrict the values assignable to ActiveRecord attributes or associations. Or enums on steroids.
+email: henning.koch@makandra.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- assignable_values.gemspec
+- lib/assignable_values.rb
+- lib/assignable_values/active_record.rb
+- lib/assignable_values/active_record/restriction/base.rb
+- lib/assignable_values/active_record/restriction/belongs_to_association.rb
+- lib/assignable_values/active_record/restriction/scalar_attribute.rb
+- lib/assignable_values/errors.rb
+- lib/assignable_values/version.rb
+- spec/app_root/.gitignore
+- spec/app_root/app/controllers/application_controller.rb
+- spec/app_root/app/models/artist.rb
+- spec/app_root/app/models/song.rb
+- spec/app_root/config/application.rb
+- spec/app_root/config/boot.rb
+- spec/app_root/config/database.yml
+- spec/app_root/config/environment.rb
+- spec/app_root/config/environments/in_memory.rb
+- spec/app_root/config/environments/mysql.rb
+- spec/app_root/config/environments/postgresql.rb
+- spec/app_root/config/environments/sqlite.rb
+- spec/app_root/config/environments/sqlite3.rb
+- spec/app_root/config/environments/test.rb
+- spec/app_root/config/initializers/backtrace_silencers.rb
+- spec/app_root/config/initializers/inflections.rb
+- spec/app_root/config/initializers/mime_types.rb
+- spec/app_root/config/initializers/secret_token.rb
+- spec/app_root/config/initializers/session_store.rb
+- spec/app_root/config/locales/en.yml
+- spec/app_root/config/routes.rb
+- spec/app_root/db/migrate/001_create_artists.rb
+- spec/app_root/db/migrate/002_create_songs.rb
+- spec/app_root/lib/tasks/.gitkeep
+- spec/app_root/script/rails
+- spec/assignable_values/active_record_spec.rb
+- spec/rcov.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/makandra/assignable_values
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.9.3
+signing_key: 
+specification_version: 3
+summary: Restrict the values assignable to ActiveRecord attributes or associations. Or enums on steroids.
+test_files: []
+