acts_as_lookup 0.0.3 → 0.1.0

data/README.rdoc

@@ -45,3 +45,9 @@ Some work is yet to be done to support general classes using acts_as_lookup
 == Configuration acts_as_lookup
 
 TODO: go through the options (enabled and FUTURE)
+
+== Development
+
+=== Testing
+
+Run rake spec to run the (rspec) tests. You should add tests for anything you touch.

data/TODO

@@ -1,22 +1,17 @@
 Things to work on:
 
 
-* find a better workaround for the cached instance problem (see https://rails.lighthouseapp.com/projects/8994/tickets/1339, for example) than explicit requiring of lookup classes (see acts_as_lookup.rb : ActsAsLookupHasLookupClassMethods#has_lookup)
 * for now, it's required to include :id in the values hashes; enhance to allow leaving :id off (by specifying :uniqueness_column) and fetch them from db (option will only be available for :sync_with_db == true)
 * allow gem to be used outside Rails by specifying alternative implementations for db-hitting methods....e.g. add configuration values that specify method names to call to load/write/remove from db. see +acts_as_lookup_fetch_values+ method comment.
 * add the following configuration options:
-** sync_with_db: if false, no inserts/retrievals of db will be performed at all. this means the model will operate as an enum-like thing...a lot like rapleaf_enum where the class just defines the mapping and when associations are formed, the id gets inserted.
-*** plan for this to work even if there is no lookup table in db at all...eg if we didn't care about foreign keys and just wanted to store some ids instead of strings....just need to make sure that associations work properly...like user.status = UserAccountStatus.active needs to set user.status_id = UserAccountStatus.active
-*** this might be kind of tricky to do without mucking with the active record association methods (belongs_to() etc.)
-*** if false, don't have the requirement that there's an :id column specified
-*** so maybe this no-table business will be FUTURE only...
-*** default will be true
-** write_to_db: if true will insert values specified in model into db table if the row doesn't exist (based on id)
-*** default will be true
-** remove_from_db: if there is an id in the table not specified in the model, will remove that row (removal will happen before any inserts)
-*** allows for there to be values in lookup table that aren't relevant for the rails app (e.g. something that only some other process needs)
-*** default will be false
-** indexed_columns: which columns can be used in lookup_by_column methods
+* if :sync_with_db false, don't have the requirement that there's an :id column specified
+** so maybe this no-table business will be FUTURE only...
+** default will be true
+* write_to_db: if true will insert values specified in model into db table if the row doesn't exist (based on id)
+** default will be true
+* remove_from_db: if there is an id in the table not specified in the model, will remove that row (removal will happen before any inserts)
+** allows for there to be values in lookup table that aren't relevant for the rails app (e.g. something that only some other process needs)
+** default will be false
 *** allows for specifying other values in the model that don't need to be lookupable columns, e.g. if there are columns with non-unique values, foreign keys to other tables etc.
 *** default will be to use all columns specified in the model
 *** probably store the lookup caches in one giant hash, each entry is a hash :column => lookup_hash_for_that_column

data/acts_as_lookup.gemspec

@@ -5,18 +5,18 @@
 
 Gem::Specification.new do |s|
   s.name = %q{acts_as_lookup}
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Percival"]
-  s.date = %q{2010-05-04}
+  s.date = %q{2011-02-23}
   s.description = %q{Provides an easy means for creating models that act like enumerations or lookup
 tables. You can specify the lookup values in your Rails models and can lazily
 push these to the associated db tables (or not). Also dynamically adds helpful
 class-level methods to access singleton instances of each value in your lookup
 table.
 }
-  s.email = %q{percivalatumamibuddotcom}
+  s.email = %q{percivalatdiscovereadsdotcom}
   s.extra_rdoc_files = [
     "LICENSE",
      "README.rdoc",
@@ -30,14 +30,18 @@ table.
   s.homepage = %q{http://github.com/bmpercy/acts_as_lookup}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.7}
   s.summary = %q{Helpful for creating lookup-table-like models}
+  s.test_files = [
+    "spec/acts_as_lookup_spec.rb",
+     "spec/spec_helper.rb"
+  ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
     else
     end
   else

data/lib/acts_as_lookup.rb

@@ -2,34 +2,36 @@
 # method
 #-------------------------------------------------------------------------------
 module ActsAsLookupClassMethods
-  def acts_as_lookup_options=(options)
-    @@acts_as_lookup_options = options
+  def self.extended(klass)
+    klass.send(:instance_variable_set, :@acts_as_lookup_options, nil)
+    klass.send(:instance_variable_set, :@acts_as_lookup_by_id, {})
+    klass.send(:instance_variable_set, :@acts_as_lookup_by_name, {})
+    klass.send(:instance_variable_set, :@acts_as_lookup_initialized, false)
+    klass.send(:instance_variable_set, :@acts_as_lookup_values, [])
   end
 
+  def acts_as_lookup_options=(options)
+    @acts_as_lookup_options = options
+  end
   def acts_as_lookup_options
-    @@acts_as_lookup_options
+    @acts_as_lookup_options
   end
 
-
   # FUTURE: allow for dynamically specifying which columns can be used for
   #         cache lookups
   #-----------------------------------------------------------------------------
   def lookup_by_id(id)
-    @@acts_as_lookup_by_id[id]
+    @acts_as_lookup_by_id[id]
   end
   def lookup_by_name(name)
-    @@acts_as_lookup_by_name[name]
+    @acts_as_lookup_by_name[name]
   end
 
 
   # check if the current lookup class has been initialized for lookup use
   #-----------------------------------------------------------------------------
   def acts_as_lookup_initialized?
-    if !defined?(@@acts_as_lookup_initialized)
-      @@acts_as_lookup_initialized = false
-    end
-
-    @@acts_as_lookup_initialized
+    @acts_as_lookup_initialized
   end
 
 
@@ -42,25 +44,22 @@ module ActsAsLookupClassMethods
     Thread.exclusive do
       # double-check in case of race condition in calling code
       unless self.acts_as_lookup_initialized?
-        @@acts_as_lookup_by_id = {}
-        @@acts_as_lookup_by_name = {}
-
-        if @@acts_as_lookup_options[:sync_with_db]
+        if acts_as_lookup_options[:sync_with_db]
           acts_as_lookup_fetch_values
-          if @@acts_as_lookup_options[:write_to_db]
+          if acts_as_lookup_options[:write_to_db]
             acts_as_lookup_write_missing_values
           end
         else
-          @@acts_as_lookup_values = @acts_as_lookup_options[:values]
+          @acts_as_lookup_values = acts_as_lookup_options[:values]
           self.acts_as_lookup_refresh_caches
         end
 
-        @@acts_as_lookup_initialized = true
+        @acts_as_lookup_initialized = true
       end
 
       # FUTURE: allow for a different column to be used for generating class
       #         accessor methods
-      @@acts_as_lookup_by_name.each_pair do |name,val|
+      @acts_as_lookup_by_name.each_pair do |name,val|
         self.acts_as_lookup_add_shortcut name
       end
 
@@ -69,6 +68,7 @@ module ActsAsLookupClassMethods
 
 
   # fetches existing records from the db and merges them into the cached values
+  # only called if :sync_with_db option is true
   #
   # FUTURE: if this gem is to be used outside of a Rails' ActiveRecord::Base
   # descendant, will need to allow calling class to specify an alternative
@@ -76,23 +76,23 @@ module ActsAsLookupClassMethods
   # call)
   #-----------------------------------------------------------------------------
   def acts_as_lookup_fetch_values
-    @@acts_as_lookup_values = self.all
+    @acts_as_lookup_values = self.all
     self.acts_as_lookup_refresh_caches
   end
 
 
   # writes any missing values to the db
+  # only called if :sync_with_db and :write_to_db options are both true
   #
   # NOTE: does NOT overwrite any values found in the db, so it is possible for
   #       the values specified in the class to be superceded by values in the
   #       database
   #-----------------------------------------------------------------------------
   def acts_as_lookup_write_missing_values
-
     # FUTURE: if :ids aren't provided, use the uniqueness_column to determine
     #         which values are missing from existing caches
-    @@acts_as_lookup_options[:values].each do |val|
-      next if @@acts_as_lookup_by_id.include?(val[:id])
+    acts_as_lookup_options[:values].each do |val|
+      next if @acts_as_lookup_by_id.include?(val[:id])
 
       # allow for attr_accessible protection, assign attributes one-by-one
       new_val = self.new
@@ -101,7 +101,7 @@ module ActsAsLookupClassMethods
       end
       new_val.save!
 
-      @@acts_as_lookup_values << new_val
+      @acts_as_lookup_values << new_val
     end
 
     self.acts_as_lookup_refresh_caches
@@ -113,9 +113,9 @@ module ActsAsLookupClassMethods
   def acts_as_lookup_refresh_caches
     # FUTURE: this will get cleaned up, and will dynamically select which
     #         columns to establish lookup caches for.
-    @@acts_as_lookup_values.each do |val|
-      @@acts_as_lookup_by_id.reverse_merge! val.id => val
-      @@acts_as_lookup_by_name.reverse_merge! val.name => val
+    @acts_as_lookup_values.each do |val|
+      @acts_as_lookup_by_id.merge!(val.id => val) unless @acts_as_lookup_by_id.include?(val.id)
+      @acts_as_lookup_by_name.merge!(val.name => val) unless @acts_as_lookup_by_name.include?(val.name)
     end
   end
 
@@ -134,7 +134,6 @@ module ActsAsLookupClassMethods
   #       to lookup by name
   #-----------------------------------------------------------------------------
   def acts_as_lookup_add_shortcut(name)
-
     method_name = name.gsub(/ /, '_')
     unless method_name.upcase == method_name
       method_name.downcase!
@@ -146,7 +145,6 @@ module ActsAsLookupClassMethods
 
     instance_eval "def #{method_name}; self.lookup_by_name '#{name}'; end"
   end
-
 end
 
 # modify object to allow any class to act like a lookup class
@@ -161,8 +159,8 @@ class Object
   def self.acts_as_lookup(options = {})
     self.extend ActsAsLookupClassMethods
 
-    options.reverse_merge! :sync_with_db => true,
-                           :write_to_db => true  #,
+    options.merge!(:sync_with_db => true) unless options.include?(:sync_with_db)
+    options.merge!(:write_to_db => true) unless options.include?(:write_to_db)
 # FUTURE:
 #                           :remove_from_db => false,
 #                           :shortcut_method_column => :name
@@ -189,21 +187,14 @@ if defined?(ActiveRecord)
     #               classname (in CamelCase) for the association.
     #---------------------------------------------------------------------------
     def has_lookup(association_name, options = {})
+      cname = options[:class_name] || association_name.to_s.camelize
 
-      class_name = options[:class_name] || association_name.to_s.camelize
-
-      # this is a hack that is not at all pretty but seems to get around the
-      # double-class loading problems that arise in rails: see for example
-      # https://rails.lighthouseapp.com/projects/8994/tickets/1339
-      # it may create other problems though, so be careful....
-      if !Object.const_defined?(class_name)
-        require File.join(RAILS_ROOT, 'app', 'models', class_name.underscore)
-      end
+      force_class_load cname
 
       # this is inspired/borrowed from Rapleaf's has_rap_enum
-      klass = Kernel.const_get(class_name)
+      klass = Kernel.const_get(cname)
       unless(klass && klass.is_a?(ActsAsLookupClassMethods))
-        raise "#{class_name.to_s.camelize} is not an acts_as_lookup class"
+        raise "#{cname.to_s.camelize} is not an acts_as_lookup class"
       end
 
       # create the reader method for the lookup association
@@ -220,6 +211,18 @@ if defined?(ActiveRecord)
       end
     end
 
+    # separate the logic for forcing a class load to isolate it, as well as
+    # making testing easier
+    #---------------------------------------------------------------------------
+    def force_class_load(cname)
+      # this is a hack that is not at all pretty but seems to get around the
+      # double-class loading problems that arise in rails: see for example
+      # https://rails.lighthouseapp.com/projects/8994/tickets/1339
+      # it may create other problems though, so be careful....
+      if !Object.const_defined?(cname)
+        require File.join(RAILS_ROOT, 'app', 'models', cname.underscore)
+      end
+    end
   end
 
   ActiveRecord::Base.extend ActsAsLookupHasLookupClassMethods

data/spec/acts_as_lookup_spec.rb

@@ -0,0 +1,436 @@
+require 'spec_helper'
+
+module ActiveRecord
+  class Base
+
+  end
+end
+
+# add a helper method that's defined in rails...the gem only uses it if
+# ActiveRecord is defined
+class String
+  def camelize
+    splits = self.split("_")
+    splits.map! do |s|
+      s.downcase!
+      s[0] = s[0].upcase
+      s
+    end
+    splits.join
+  end
+end
+
+# a dummy lookup class (see has_lookup tests)
+class DummyLookup < Struct.new(:id, :name)
+  def self.one_instance
+    self.new(1,"dummy one")
+  end
+
+  def self.another_instance
+    self.new(2,"dummy two")
+  end
+
+  def self.yet_another_instance
+    self.new(3,"dummy three")
+  end
+end
+
+describe "ActsAsLookup" do
+  # this is kinda hacky, but what we're doing here is trying to clear out all
+  # entries in namespace for acts as lookup between each run so that we don't
+  # see any bugs that are tied to double-loading the acts as lookup
+  # infrastructure
+  # so we:
+  #   - unload all classes that are either part of gem or are test classes
+  #   - reload the acts as lookup lib file
+  #   - re-declare each of the test classes we're using
+  #
+  # (alternative would be to generate new classes for each test but that's
+  # likely equally messy with dynamically defined class names etc.)
+  #-----------------------------------------------------------------------------
+  before :each do
+    Object.constants.each do |klass|
+      if (klass.to_s =~ /LookupClass/) && (Object.const_defined?(klass.to_s))
+        Object.send(:remove_const,klass.to_s)
+      end
+    end
+    load File.join(File.dirname(__FILE__), '../lib/acts_as_lookup.rb')
+
+    class ClassOnlyLookupClass < Struct.new(:id, :name); end
+
+    # another one to detect shared var conflict
+    class SecondClassOnlyLookupClass < Struct.new(:id, :name); end
+
+    # all values are in db and in class specification
+    class ActiveRecordLookupClassWithAllValuesInDbAndClass < Struct.new(:id, :name)
+      ALL_VALUES = [self.new(1, "one"), self.new(2, "two")]
+
+      def self.all_values
+        ALL_VALUES
+      end
+
+      def self.class_vals
+        all_values
+      end
+
+      def self.all
+        all_values
+      end
+    end
+    # some values are in db; the rest are in class specification
+    class ActiveRecordLookupClassWithSomeValuesInDb < Struct.new(:id, :name)
+      ALL_VALUES = [self.new(1, "one"), self.new(2, "two"), self.new(3, "three")]
+
+      def self.all_values
+        ALL_VALUES
+      end
+
+      def self.db_missing_val
+        all_values[1]
+      end
+
+      def self.class_vals
+        all_values
+      end
+
+      # don't return all vals in query
+      def self.all
+        all_values.reject { |v| v.id == db_missing_val.id }
+      end
+
+      # a method for checking what's saved when save! is called
+      def self.created_val(val)
+        # doesn't need to do anything
+      end
+
+      # "active record" method for creating new lookup values
+      def save!
+        self.class.created_val(self)
+      end
+    end
+    # all values in db; some are in class specification
+    class ActiveRecordLookupClassWithSomeValuesInClass < Struct.new(:id, :name)
+      ALL_VALUES = [self.new(1, "one"), self.new(2, "two"), self.new(3, "three")]
+
+      def self.all_values
+        ALL_VALUES
+      end
+
+      def self.class_missing_val
+        all_values[1]
+      end
+
+      def self.class_vals
+        all_values.reject { |v| v.id == class_missing_val.id }
+      end
+
+      # return all vals in query
+      def self.all
+        all_values
+      end
+    end
+    class ClassWithLookupClass < ActiveRecord::Base
+      attr_accessor :dummy_lookup_id
+      attr_accessor :other_lookup_id
+    end
+
+  end
+
+  #-----------------------------------------------------------------------------
+  describe "class-only (non ActiveRecord) lookup classes" do
+    it "should not insert any new values if :write_to_db is false" do
+      klass = ClassOnlyLookupClass
+      klass.should_not_receive :acts_as_lookup_write_missing_values
+      instances = [klass.new(1, "one"), klass.new(2, "two")]
+
+      klass.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances
+      )
+    end
+
+    it "should not query values if :sync_with_db is false" do
+      klass = ClassOnlyLookupClass
+      klass.should_not_receive :all
+      instances = [klass.new(1, "one"), klass.new(2, "two")]
+
+      klass.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances
+      )
+    end
+  end
+
+  # "active record" tests
+  # note: these test classes aren't really active record classes (to enable
+  #       testing in absence of active record), but mimic enough of the
+  #       interface for the tests
+
+  #-----------------------------------------------------------------------------
+  describe "when active record lookup class specifies all values and db has all values" do
+    it "should run select query if :sync_with_db is true" do
+      klass = ActiveRecordLookupClassWithAllValuesInDbAndClass
+
+      klass.should_receive(:all).and_return klass.all_values
+
+      klass.acts_as_lookup(
+        :values => klass.class_vals
+      )
+    end
+
+    it "should not insert any new values even if :write_to_db is true" do
+      klass = ActiveRecordLookupClassWithAllValuesInDbAndClass
+
+      klass.should_not_receive(:new)
+
+      klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => klass.class_vals
+      )
+    end
+
+    it "should return correct value accessed by lookup_by_id" do
+      klass = ActiveRecordLookupClassWithAllValuesInDbAndClass
+      klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => klass.class_vals
+      )
+
+      klass.lookup_by_id(klass.all_values.first.id).should == klass.all_values.first
+    end
+
+    it "should return correct value accessed by lookup_by_name" do
+      klass = ActiveRecordLookupClassWithAllValuesInDbAndClass
+      klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => klass.class_vals
+      )
+
+      klass.lookup_by_name(klass.all_values.last.name).should == klass.all_values.last
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  describe "when lookup class specifies all lookup values but db only specifies some" do
+    before :each do
+      @klass = ActiveRecordLookupClassWithSomeValuesInDb
+    end
+
+    it "should run select query if :sync_with_db is true" do
+      all_result = @klass.all
+
+      @klass.should_receive(:all).and_return all_result
+
+      @klass.acts_as_lookup(
+        :values => @klass.class_vals
+      )
+    end
+
+    it "should insert any new values when :write_to_db is true" do
+      # this is a dummy class method that gets called when instance method
+      # save! is called, so we can check what was created
+      @klass.should_receive(:created_val) { |val|
+        val.id.should == @klass.db_missing_val.id
+        val.name.should == @klass.db_missing_val.name
+      }
+
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+    end
+
+    it "should return correct value accessed by lookup_by_id" do
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+
+      @klass.lookup_by_id(@klass.db_missing_val.id).should == @klass.db_missing_val
+    end
+
+    it "should return correct value accessed by lookup_by_name" do
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+
+      @klass.lookup_by_name(@klass.db_missing_val.name).should == @klass.db_missing_val
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  describe "when lookup class doesn't specify all lookup values but db does" do
+    before :each do
+      @klass = ActiveRecordLookupClassWithSomeValuesInClass
+    end
+
+    it "should run select query if :sync_with_db is true" do
+      all_result = @klass.all
+
+      @klass.should_receive(:all).and_return all_result
+
+      @klass.acts_as_lookup(
+        :values => @klass.class_vals
+      )
+    end
+
+    it "shouldn't insert any new values even if :write_to_db is true" do
+      @klass.should_not_receive(:new)
+
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+    end
+
+    it "should return correct value accessed by lookup_by_id" do
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+
+      @klass.lookup_by_id(@klass.class_missing_val.id).should == @klass.class_missing_val
+    end
+
+    it "should return correct value accessed by lookup_by_name" do
+      @klass.acts_as_lookup(
+        :write_to_db => true,
+        :values => @klass.class_vals
+      )
+
+      @klass.lookup_by_name(@klass.class_missing_val.name).should == @klass.class_missing_val
+    end
+  end
+
+  #-----------------------------------------------------------------------------
+  describe "single-lookup-class scenarios" do
+    before :each do
+      @klass = ActiveRecordLookupClassWithSomeValuesInClass
+      @klass.acts_as_lookup(:values => @klass.class_vals)
+    end
+
+    it "should not query values on calls to lookup_by_id" do
+      @klass.should_not_receive(:find)
+      @klass.should_not_receive(:find_by_id)
+
+      @klass.lookup_by_id(1)
+    end
+
+    it "should not query values calls to lookup_by_name" do
+      @klass.should_not_receive(:find)
+      @klass.should_not_receive(:find_by_name)
+
+      @klass.lookup_by_name('one')
+    end
+
+    it "should dynamically add specific methods to access lookup value by name" do
+      @klass.all_values.each do |val|
+        @klass.send(val.name.to_sym).should == val
+      end
+    end
+  end
+
+  describe "two-lookup-class scenarios" do
+    it "should return the correct object (type) even if ids overlap between two lookup classes" do
+      klass1 = ClassOnlyLookupClass
+      klass2 = SecondClassOnlyLookupClass
+      instances1 = [klass1.new(1, "one"), klass1.new(2, "two")]
+      instances2 = [klass2.new(1, "class two one"), klass2.new(2, "class two two")]
+      klass1.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances1
+      )
+      klass2.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances2
+      )
+
+      klass1.lookup_by_id(1).should == instances1.first
+      klass2.lookup_by_id(1).should == instances2.first
+    end
+
+    it "should return the correct object (type) even if names overlap between two lookup classes" do
+      klass1 = ClassOnlyLookupClass
+      klass2 = SecondClassOnlyLookupClass
+      instances1 = [klass1.new(3, "three"), klass1.new(4, "four")]
+      instances2 = [klass2.new(33, "three"), klass2.new(44, "four")]
+      klass1.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances1
+      )
+      klass2.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances2
+      )
+
+      klass1.lookup_by_name('four').should == instances1.last
+      klass2.lookup_by_name('four').should == instances2.last
+    end
+
+    it "should keep acts as lookup options separate for different lookup classes" do
+      klass1 = ClassOnlyLookupClass
+      klass2 = SecondClassOnlyLookupClass
+      instances1 = [klass1.new(1, "one"), klass1.new(2, "two")]
+      instances2 = [klass2.new(3, "three"), klass2.new(4, "four")]
+      klass1.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances1
+      )
+      klass2.acts_as_lookup(
+        :sync_with_db => false,
+        :values => instances2
+      )
+
+      klass1.acts_as_lookup_options[:values].should == instances1
+      klass2.acts_as_lookup_options[:values].should == instances2
+    end
+  end
+
+  describe "when using has_lookup to associate classes" do
+    it "should not make a db hit to look up a single record when accessing a has_lookup accessor" do
+      DummyLookup.acts_as_lookup(
+        :values => [DummyLookup.one_instance],
+        :sync_with_db => false
+      )
+      klass = ClassWithLookupClass
+      klass.has_lookup :dummy_lookup
+      lookup_instance = DummyLookup.one_instance
+
+      instance = klass.new
+      instance.dummy_lookup_id = lookup_instance.id
+
+      instance.dummy_lookup.should == lookup_instance
+    end
+
+    it "should set the id attribute of an object that has_lookup when the whole-object setter is used" do
+      DummyLookup.acts_as_lookup(
+        :values => [DummyLookup.another_instance],
+        :sync_with_db => false
+      )
+      klass = ClassWithLookupClass
+      klass.has_lookup :dummy_lookup
+      lookup_instance = DummyLookup.one_instance
+
+      instance = klass.new
+      instance.dummy_lookup = lookup_instance
+
+      instance.dummy_lookup_id.should == lookup_instance.id
+    end
+
+    it "should allow overriding the class name on a has_lookup association" do
+      DummyLookup.acts_as_lookup(
+        :values => [DummyLookup.yet_another_instance],
+        :sync_with_db => false
+      )
+      klass = ClassWithLookupClass
+      klass.has_lookup :other_lookup, :class_name => 'DummyLookup'
+      lookup_instance = DummyLookup.one_instance
+
+      instance = klass.new
+      instance.other_lookup = lookup_instance
+
+      instance.other_lookup_id.should == lookup_instance.id
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '../lib/acts_as_lookup')

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_lookup
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Brian Percival
@@ -9,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-04 00:00:00 -07:00
+date: 2011-02-23 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -20,7 +26,7 @@ description: |
   class-level methods to access singleton instances of each value in your lookup
   table.
 
-email: percivalatumamibuddotcom
+email: percivalatdiscovereadsdotcom
 executables: []
 
 extensions: []
@@ -35,6 +41,8 @@ files:
 - lib/acts_as_lookup.rb
 - LICENSE
 - TODO
+- spec/acts_as_lookup_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/bmpercy/acts_as_lookup
 licenses: []
@@ -45,23 +53,30 @@ 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"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Helpful for creating lookup-table-like models
-test_files: []
-
+test_files: 
+- spec/acts_as_lookup_spec.rb
+- spec/spec_helper.rb