rails_lookup 0.0.1 → 0.0.2

data/README

@@ -5,6 +5,8 @@ By: Nimrod Priell
 
 This gem adds an ActiveRecord macro to define memory-cached, dynamically growing, normalized lookup tables for entity 'type'-like objects. Or in plain English - if you want to have a table containing, say, ProductTypes which can grow with new types simply when you refer to them, and not keep the Product table containing a thousand repeating 'type="book"' entries - sit down and try to follow through.
 
+Installation is described down the page.
+
 Motivation
 ----------
 
@@ -81,6 +83,7 @@ I've looked thoroughly for a nice rails solution to this, but after failing to f
 
 Installation
 ------------
+First, run `gem install rails_lookup` to install the latest version of the gem.
 
 The result of this hook is that you get the exact syntax described above, with only two lines of code (no extra classes or anything):
 In your ActiveRecord object simply add

data/Rakefile

@@ -2,7 +2,7 @@ require 'rubygems'
 require 'rake'  
 require 'echoe'  
   
-Echoe.new('rails_lookup', '0.0.1') do |s|  
+Echoe.new('rails_lookup', '0.0.2') do |s|  
   s.description = File.read(File.join(File.dirname(__FILE__), 'README')) 
   s.summary     = "Lookup table macro for ActiveRecords" 
   s.url             = "http://github.com/Nimster/RailsLookup/"

data/lib/active_record/lookup.rb

@@ -5,130 +5,149 @@
 # include ActiveRecord::Lookup
 # in your class that extends ActiveRecord::Base
 module ActiveRecord
-module Lookup
-  #These will be defined as class methods.
-  module ClassMethods
-    #We define only this "macro". In your ActiveRecord entity (say, Car), use
-    # lookup :car_type
-    # which will create Car#car_type, Car#car_type=, Car#car_type_id,
-    # Car#car_type_id= and CarType, an ActiveRecord with a name (String)
-    # attribute, that has_many :cars. 
-    # 
-    # You can also use
-    # lookup :car_type, :as => :type
-    # which will do the same thing but create Car#type, Car#type=, Car#type_id
-    # and Car#type_id= instead.
-    def lookup(lookup_name, opts = {})
-      as_name = opts[:as] || lookup_name
-      mycls = self #Class I'm defined in
-
-      #Create the new ActiveRecord for the lookup
-      cls = Class.new(ActiveRecord::Base) do 
-        #It has_many of the containing class
-        has_many mycls.to_s.split(/[A-Z]/).map(&:downcase).join('_').to_sym
-
-        validates_uniqueness_of :name
-        validates :name, :presence => true
-
-        #Query the cache for the DB ID of a certain value
-        def self.id_for(name, id = nil)
-          class_variable_get(:@@rcaches)[name] ||= id
-        end
+  module Lookup
+    #These will be defined as class methods so they can be called as "macros"
+    #like belongs_to
+    module ClassMethods
+      #We define only this "macro". In your ActiveRecord entity (say, Car), use
+      # lookup :car_type
+      # which will create Car#car_type, Car#car_type=, Car#car_type_id,
+      # Car#car_type_id= and CarType, an ActiveRecord with a name (String)
+      # attribute, that has_many :cars. 
+      # 
+      # You can also use
+      # lookup :car_type, :as => :type
+      # which will do the same thing but create Car#type, Car#type=, Car#type_id
+      # and Car#type_id= instead.
+      def lookup(lookup_name, opts = {})
+        as_name = opts[:as] || lookup_name
+
+        #Define the setter for the attribute by textual value
+        mycls = self #Class I'm defined in
+        #Ignore anonymous classes:
+        mycls_sym = mycls.name.tableize.to_sym unless mycls.to_s =~ /#<.*>/ 
+        lookup_cls_name = lookup_name.to_s.camelize
+        begin
+          #If it exists, just tack on the extra has_many
+          cls = Object.const_get lookup_cls_name
+          cls.has_many mycls_sym unless mycls_sym.blank? #for annon classes
+        rescue NameError
+          #Otherwise, actually define it
+          cls = Class.new(ActiveRecord::Base) do 
+            has_many mycls_sym unless mycls_sym.blank? #For anon classes
+            validates_uniqueness_of :name
+            validates :name, :presence => true
+
+            def self.id_for(name, id = nil)
+              class_variable_get(:@@rcaches)[name] ||= id
+            end
 
-        #This helper method is the "find_or_create" of the class that also
-        #updates the DB. I didn't want to overwrite the original
-        #find_or_create_by_name since it is linked with a lot of the rails
-        #behaviour and I want to avoid altering that.
-        def self.gen_id_for(val)
-          id = id_for val
-          if id.nil?
-            #Define this new possible value
-            new_db_obj = find_or_create_by_name val #You could just override this...
-            id_for val, new_db_obj.id
-            name_for new_db_obj.id, val
-            id = new_db_obj.id
+            def self.gen_id_for(val)
+              id = id_for val
+              if id.nil?
+                #Define this new possible value
+                new_db_obj = find_or_create_by_name val #You could just override this...
+                id_for val, new_db_obj.id
+                name_for new_db_obj.id, val
+                id = new_db_obj.id
+              end
+              id
+            end
+
+            def self.name_for(id, name = nil)
+              class_variable_get(:@@caches)[id] ||= name
+            end
+
+            #This is especially useful for tests - you want deletion to also clear
+            #the caches otherwise odd stuff might happen
+            def self.delete_all(*args)
+              class_variable_set :@@caches, []
+              class_variable_set :@@rcaches, {}
+              super *args
+            end
           end
-          id
+
+          Object.const_set lookup_cls_name, cls #Define it as a global class
         end
 
-        #Query the cache for the value that goes with a certain DB ID
-        def self.name_for(id, name = nil)
-          class_variable_get(:@@caches)[id] ||= name
+
+        define_method("#{as_name.to_s}_id=") do |id|
+          write_attribute "#{as_name.to_s}".to_sym, id
         end
-      end
 
-      #Bind the created class to a name
-      lookup_cls_name = lookup_name.to_s.split("_").map(&:capitalize).join("")
-      Object.const_set lookup_cls_name, cls #Define it as a global class
+        define_method("#{as_name.to_s}=") do |val|
+          id = cls.gen_id_for val #TODO: Just call #{as_name.to_s}_id=
+          write_attribute "#{as_name.to_s}".to_sym, id
+        end
 
-      #Define the setter by string value
-      define_method("#{as_name.to_s}=") do |val|
-        id = cls.gen_id_for val
-        write_attribute "#{as_name.to_s}_id".to_sym, id
-      end
+        define_method("#{as_name.to_s}_id") do 
+          read_attribute "#{as_name.to_s}".to_sym
+        end
 
-      #Define the getter
-      define_method("#{as_name.to_s}") do 
-        id = read_attribute "@#{as_name.to_s}_id".to_sym
-        if not id.nil?
-          value = cls.name_for id
-          if value.nil?
-            lookup_obj = cls.find_by_id id
-            if not lookup_obj.nil?
-              cls.name_for id, lookup_obj.name
-              cls.id_for lookup_obj.name, id
+        #Define the getter
+        define_method("#{as_name.to_s}") do 
+          id = read_attribute "#{as_name.to_s}".to_sym
+          if not id.nil?
+            value = cls.name_for id
+            if value.nil?
+              lookup_obj = cls.find_by_id id
+              if not lookup_obj.nil?
+                #TODO: Extract to a method
+                cls.name_for id, lookup_obj.name
+                cls.id_for lookup_obj.name, id
+              end
             end
           end
+          value
         end
-        value
-      end
 
-      #This sucks but it's the only way I could figure out to create the exact
-      #method_missing method signature and still pass it the values I need to
-      #use it. Maybe these should be class variables, but the best thing is if
-      #they could only be defined in this scope and carried along with the
-      #closure to the actual method.
-      @as_name = as_name
-      @cls = cls 
-      #We need to wrap around rails' default finders so that
-      #find_by_car_type and similar methods will behave correctly. We translate
-      #them on the fly to find_by_car_type_id and give the id instead of the
-      #requested name.
-      def method_missing(method_id, *arguments, &block)
-        if match = ActiveRecord::DynamicFinderMatch.match(method_id)
-          #reroute car_type to _car_type_id
-          idx = match.attribute_names.find_index { |n| n == @as_name.to_s }
-          if not idx.nil?
-            self.new.send "#{@as_name}=", arguments[idx] #Make sure there's a cached value
-            arguments[idx] = @cls.id_for arguments[idx] #Change the argument
-            method_id = method_id.to_s.sub /(by|and)_#{@as_name}$/, "\\1_#{@as_name}_id"
-            method_id = method_id.to_s.sub /(by|and)_#{@as_name}_and/, "\\1_#{@as_name}_id_and"
-            method_id = method_id.to_sym
+
+        #Rails ActiveRecord support:
+        @cls_for_name = {} if @cls_for_name.nil?
+        @cls_for_name[as_name.to_s.to_sym] = cls
+        #We need to override this for the dynamic finders.
+        def method_missing(method_id, *arguments, &block)
+          if match = ActiveRecord::DynamicFinderMatch.match(method_id)
+            #reroute kind to _kind_id
+            idxs = match.attribute_names.collect.with_index { |n,i| [i,n.to_sym] if @cls_for_name.has_key? n.to_sym }.compact
+            idxs.each do |elm|
+              if method_id =~ /^find_by_/
+                arguments[elm[0]] = @cls_for_name[elm[1]].gen_id_for arguments[elm[0]] #Change the argument
+              end
+            end 
           end 
-        end 
-        super
+          super
+        end
+
+        def where(opts, *rest)
+          #Change the values of the keys in the lookup to their ids
+          mapped = opts.map { |k,v| @cls_for_name.has_key?(k) ? [k, @cls_for_name[k].id_for(v)] : [k, v] }
+          opts = Hash[mapped]
+          super(opts, *rest)
+        end
+
+        #Might need to be in class_eval
+        belongs_to lookup_name.to_s.to_sym, :foreign_key => "#{as_name}_id"
+        validates as_name.to_s.to_sym, :presence => true
+
+        #Prefill the hashes from the DB:
+        all_vals = cls.all
+        #No need for the class_exec
+        cls.class_variable_set(:@@rcaches, all_vals.inject({}) do |r, obj|
+          r[obj.name] = obj.id
+          r
+        end)
+        cls.class_variable_set(:@@caches, all_vals.inject([]) do |r, obj|
+          r[obj.id] = obj.name
+          r
+        end)
       end
 
-      #Define the link between the host class and the newly created ActiveRecord
-      belongs_to lookup_name.to_s.to_sym, :foreign_key => "#{as_name}_id".to_sym
-      validates "#{as_name.to_s}_id".to_sym, :presence => true
-
-      #Prefill the hashes from the DB
-      all_vals = cls.all
-      cls.class_variable_set(:@@rcaches, all_vals.inject({}) do |r, obj|
-        r[obj.name] = obj.id
-        r
-      end)
-      cls.class_variable_set(:@@caches, all_vals.inject([]) do |r, obj|
-        r[obj.id] = obj.name
-        r
-      end)
     end
-  end
 
-  # extend host class with class methods when we're included 
-  def self.included(host_class)
-    host_class.extend(ClassMethods) 
+    # extend host class with class methods when we're included 
+    def self.included(host_class)
+      host_class.extend(ClassMethods) 
+    end
   end
 end
-end

data/rails_lookup.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails_lookup}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Nimrod Priell}]
-  s.date = %q{2011-08-06}
+  s.date = %q{2011-08-08}
   s.description = %q{Lookup tables with ruby-on-rails
 --------------------------------
 
@@ -14,6 +14,8 @@ By: Nimrod Priell
 
 This gem adds an ActiveRecord macro to define memory-cached, dynamically growing, normalized lookup tables for entity 'type'-like objects. Or in plain English - if you want to have a table containing, say, ProductTypes which can grow with new types simply when you refer to them, and not keep the Product table containing a thousand repeating 'type="book"' entries - sit down and try to follow through.
 
+Installation is described down the page.
+
 Motivation
 ----------
 
@@ -90,6 +92,7 @@ I've looked thoroughly for a nice rails solution to this, but after failing to f
 
 Installation
 ------------
+First, run `gem install rails_lookup` to install the latest version of the gem.
 
 The result of this hook is that you get the exact syntax described above, with only two lines of code (no extra classes or anything):
 In your ActiveRecord object simply add
@@ -149,13 +152,14 @@ I hope this helped you and saved a lot of time and frustration. Follow me on twi
 }
   s.email = %q{@nimrodpriell}
   s.extra_rdoc_files = [%q{README}, %q{lib/active_record/lookup.rb}]
-  s.files = [%q{README}, %q{Rakefile}, %q{lib/active_record/lookup.rb}, %q{Manifest}, %q{rails_lookup.gemspec}]
+  s.files = [%q{README}, %q{Rakefile}, %q{lib/active_record/lookup.rb}, %q{rails_lookup.gemspec}, %q{test/20110808002412_create_test_lookup_db.rb}, %q{test/test_lookup.rb} ]
   s.homepage = %q{http://github.com/Nimster/RailsLookup/}
   s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{Rails_lookup}, %q{--main}, %q{README}]
   s.require_paths = [%q{lib}]
   s.rubyforge_project = %q{rails_lookup}
   s.rubygems_version = %q{1.8.7}
   s.summary = %q{Lookup table macro for ActiveRecords}
+  s.test_files = [%q{test/test_lookup.rb}]
 
   if s.respond_to? :specification_version then
     s.specification_version = 3

data/test/20110808002412_create_test_lookup_db.rb

@@ -0,0 +1,35 @@
+class CreateTestLookupDb < ActiveRecord::Migration
+  def self.up
+    create_table :cars do |t|
+      t.integer :kind
+      t.integer :color
+      t.string :name
+
+      t.timestamps
+    end
+    
+    create_table :car_kinds do |t|
+      t.string :name
+    end
+    create_table :planes do |t|
+      t.integer :kind
+      t.string :name
+
+      t.timestamps
+    end
+    create_table :plane_kinds do |t|
+      t.string :name
+    end
+    create_table :car_colors do |t|
+      t.string :name
+    end
+  end
+
+  def self.down
+    drop_table :cars
+    drop_table :car_kinds
+    drop_table :car_colors
+    drop_table :planes
+    drop_table :plane_kinds
+  end
+end

data/test/test_lookup.rb

@@ -0,0 +1,223 @@
+require 'lookup'
+require 'minitest/autorun'
+
+class Car < ActiveRecord::Base
+  include Lookup
+  lookup :car_kind, :as => :kind
+  lookup :car_color, :as => :color
+end
+
+class Plane < ActiveRecord::Base
+  include Lookup
+  lookup :plane_kind, :as => :kind
+end
+
+class TestLookup < MiniTest::Unit::TestCase
+
+  def setup
+    clear_tables
+  end
+
+  def teardown
+    clear_tables
+  end
+
+  def clear_tables
+    Car.delete_all
+    CarKind.delete_all
+    CarColor.delete_all
+    Plane.delete_all
+    PlaneKind.delete_all
+  end
+
+  def test_initializers
+    assert_equal 0, CarKind.count
+    assert_equal 0, CarColor.count
+    bimba = Car.new(:name => "Bimba", :kind => "Compact", :color => "Yellow")
+    assert_equal "Yellow", bimba.color
+    assert_equal "Compact", bimba.kind
+    assert_equal "Bimba", bimba.name
+    assert_equal 1, CarKind.count
+    assert_equal 1, CarColor.count
+    ferrari = Car.new(:kind => "Sports", :color => "Yellow")
+    assert_equal "Yellow", ferrari.color
+    assert_equal "Sports", ferrari.kind
+    refute(ferrari == bimba)
+    assert_equal bimba.color_id, ferrari.color_id
+    refute_equal bimba.kind_id, ferrari.kind_id
+    assert_equal 2, CarKind.count
+    assert_equal 1, CarColor.count
+    f16 = Plane.new(:name => "F-16", :kind => "Fighter Jet")
+    assert_equal "Fighter Jet", f16.kind
+    assert_equal 1, PlaneKind.count
+  end
+
+  def test_saving_and_creating
+    bimba = Car.new(:name => "Bimba", :kind => "Compact", :color => "Yellow")
+    assert_equal "Yellow", bimba.color
+    assert_equal "Compact", bimba.kind
+    assert_equal "Bimba", bimba.name
+    bimba.save!
+    bimba_reloaded = Car.all.first
+    assert_equal "Yellow", bimba_reloaded.color
+    assert_equal "Compact", bimba_reloaded.kind
+    assert_equal "Bimba", bimba_reloaded.name
+    ferrari = Car.create!(:kind => "Sports", :color => "Yellow")
+    assert_equal "Yellow", ferrari.color
+    assert_equal "Sports", ferrari.kind
+    ferrari_reloaded = Car.all.last
+    assert_equal "Yellow", ferrari_reloaded.color
+    assert_equal "Sports", ferrari_reloaded.kind
+  end
+
+  def test_string_setting_and_getting
+    bimba = Car.new
+    ferrari = Car.new
+    assert_equal 0, CarKind.count
+    assert_equal 0, CarColor.count
+    bimba.color = "Yellow"
+    bimba.name = "Bimba"
+    bimba.kind = "Compact"
+    assert_equal "Yellow", bimba.color
+    assert_equal "Compact", bimba.kind
+    assert_equal "Bimba", bimba.name
+    assert_equal 1, CarKind.count
+    assert_equal 1, CarColor.count
+    ferrari.color = "Yellow"
+    ferrari.kind = "Sports"
+    assert_equal "Yellow", ferrari.color
+    assert_equal "Sports", ferrari.kind
+    assert_equal bimba.color_id, ferrari.color_id
+    refute_equal bimba.kind_id, ferrari.kind_id
+    assert_equal 2, CarKind.count
+    assert_equal 1, CarColor.count
+    bimba.color = "Red"
+    assert_equal 2, CarColor.count
+    assert_equal "Red", bimba.color
+    refute(bimba.color == ferrari.color)
+    bimba.color_id = ferrari.color_id #Set via the property_id
+    assert_equal "Yellow", bimba.color
+  end
+
+  def test_id_for_name_for
+    bimba = Car.new
+    assert_nil CarKind.id_for("Compact")
+    assert_nil CarKind.name_for(1)
+    bimba.kind = "Compact"
+    assert_equal bimba.kind_id, CarKind.id_for("Compact")
+    assert_equal "Compact", CarKind.name_for(bimba.kind_id)
+  end
+
+  def test_find_by
+    bimba = Car.create! :name => "Bimba", :kind => "Compact", :color => "Yellow"
+    ferrari = Car.create! :kind => "Sports", :color => "Yellow"
+    bimba2 = Car.find_by_kind_and_name "Compact", "Bimba"
+    assert_equal bimba, bimba2
+    assert_equal "Yellow", bimba2.color
+    bimba2 = Car.find_by_name_and_kind "Bimba", "Compact"
+    assert_equal bimba, bimba2
+    assert_equal "Yellow", bimba2.color
+    bimba2 = Car.find_by_kind "Compact"
+    assert_equal bimba, bimba2
+    assert_equal "Yellow", bimba2.color
+    bimba2 = Car.find_by_kind_and_color_and_name "Compact", "Yellow", "Bimba"
+    assert_equal bimba, bimba2
+    assert_equal "Yellow", bimba2.color
+    assert_equal "Compact", bimba2.kind
+    susita = Car.find_or_create_by_name_and_kind_and_color "Susita", "Compact", "Gray"
+    assert_equal "Gray", susita.color
+    assert_equal "Compact", susita.kind
+    bimba2 = Car.find_or_create_by_name_and_kind_and_color "Bimba", "Compact", "Yellow"
+    assert_equal "Yellow", bimba2.color
+    assert_equal "Compact", bimba2.kind
+    assert_equal "Bimba", bimba2.name
+    f16 = Plane.find_or_create_by_kind_and_name "Fighter Jet", "F-16"
+    assert_equal "Fighter Jet", f16.kind
+    assert_equal "F-16", f16.name
+    ferrari = Car.find_or_create_by_kind_and_color "Sports", "Yellow"
+    assert_equal "Yellow", ferrari.color
+    assert_equal "Sports", ferrari.kind
+    batmobile = Car.find_or_create_by_kind_and_color "Fantasy", "Black"
+    assert_equal "Black", batmobile.color
+    assert_equal "Fantasy", batmobile.kind
+    assert_equal 3, CarKind.count
+    assert_equal 3, CarColor.count
+    assert_equal 1, PlaneKind.count
+  end
+
+  #This test will issue warnings as we re-set existing constants
+  def test_preload_caches
+    #We have to define a new ActiveRecord class for this
+    CarKind.create! name: "Compact"
+    CarKind.create! name: "Sports"
+    assert_nil CarKind.id_for("Compact")
+    assert_nil CarKind.id_for("Sports")
+    #We get a new CarKind class - but this one will be preloaded
+    tmp = CarKind
+    Class.new(ActiveRecord::Base) do
+      include Lookup
+      lookup :car_kind
+    end
+    refute_nil CarKind.id_for("Compact")
+    refute_nil CarKind.id_for("Sports")
+    refute_equal CarKind.id_for("Compact"), CarKind.id_for("Sports")
+    assert_equal "Compact", CarKind.name_for(CarKind.id_for("Compact"))
+    assert_equal "Sports", CarKind.name_for(CarKind.id_for("Sports"))
+    #Revert to the old class
+    #Object.const_set "CarKind", tmp
+  end
+
+  def test_where
+    bimba = Car.create! :name => "Bimba", :kind => "Compact", :color => "Yellow"
+    ferrari = Car.create! :kind => "Sports", :color => "Yellow"
+    assert_equal 1, Car.where(kind: "Compact").count
+    assert_equal 2, Car.where(color: "Yellow").count
+    assert_equal 0, Car.where(color: "Red").count
+    assert_equal 1, Car.where(color: "Yellow", kind: "Compact").count
+    assert_equal 1, Car.where(name: "Bimba", kind: "Compact").count
+  end
+
+  #TODO: This currently fails
+  def test_belongs_to
+    bimba = Car.create! :name => "Bimba", :kind => "Compact", :color => "Yellow"
+    ferrari = Car.create! :kind => "Sports", :color => "Yellow"
+#    yellow = CarColor.find_by_name "Yellow"
+#    assert_equal 2, yellow.cars.size
+  end
+end
+
+=begin
+a = TestLookup.new
+puts "Cache hits: "
+puts(TestLookupKind.id_for "simian")
+puts "Setting test_lookup_kind: "
+a.test_lookup_kind="simian"
+puts "Reading test_lookup_kind: "
+puts a.test_lookup_kind
+puts a.test_lookup_kind_id
+
+puts "Hacking the ID: "
+a.test_lookup_kind_id = 1
+puts a.test_lookup_kind
+
+puts "Setting another_lookup_kind: "
+a.another_lookup_kind="simian"
+puts "Reading another_lookup_kind: "
+puts a.another_lookup_kind
+puts a.another_lookup_kind_id
+
+b = TestLookupKind.new
+puts "HERE"
+p TestLookupKind.all
+
+puts "Testing different class"
+b = OneMore.new
+b.taverna_kind = "williwok"
+puts b.taverna_kind
+puts b.taverna_kind_id
+
+puts "Testing original class: "
+puts a.test_lookup_kind
+puts a.another_lookup_kind
+
+=end

metadata

@@ -2,7 +2,7 @@
 name: rails_lookup
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Nimrod Priell
@@ -10,13 +10,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-06 00:00:00 Z
+date: 2011-08-08 00:00:00 Z
 dependencies: []
 
 description: "Lookup tables with ruby-on-rails\n\
   --------------------------------\n\n\
   By: Nimrod Priell\n\n\
   This gem adds an ActiveRecord macro to define memory-cached, dynamically growing, normalized lookup tables for entity 'type'-like objects. Or in plain English - if you want to have a table containing, say, ProductTypes which can grow with new types simply when you refer to them, and not keep the Product table containing a thousand repeating 'type=\"book\"' entries - sit down and try to follow through.\n\n\
+  Installation is described down the page.\n\n\
   Motivation\n\
   ----------\n\n\
   A [normalized DB][1] means that you want to keep types as separate tables, with foreign keys pointing from your main entity to its type. For instance, instead of \n\
@@ -51,7 +52,8 @@ description: "Lookup tables with ruby-on-rails\n\
   But you wanna minimize generating these numerous type classes. If you're like me, you don't even want to see them lying around in app/model. Who cares about them?\n\n\
   I've looked thoroughly for a nice rails solution to this, but after failing to find one, I created my own rails metaprogramming hook.\n\n\
   Installation\n\
-  ------------\n\n\
+  ------------\n\
+  First, run `gem install rails_lookup` to install the latest version of the gem.\n\n\
   The result of this hook is that you get the exact syntax described above, with only two lines of code (no extra classes or anything):\n\
   In your ActiveRecord object simply add\n\n    require 'active_record/lookup'\n    class Car < ActiveRecord::Base\n      #...\n      include ActiveRecord::Lookup\n      lookup :car_type\n      #...\n    end\n\n\
   That's it. the generated CarType class (which you won't see as a car_type.rb file, obviously, as it is generated in real-time), contains some nice methods to look into the cache as well: So you can call\n\n    CarType.id_for \"Sports\" #Returns 2\n    CarType.name_for 1 #Returns \"Compact\"\n\n\
@@ -74,8 +76,9 @@ files:
 - README
 - Rakefile
 - lib/active_record/lookup.rb
-- Manifest
 - rails_lookup.gemspec
+- test/20110808002412_create_test_lookup_db.rb
+- test/test_lookup.rb
 homepage: http://github.com/Nimster/RailsLookup/
 licenses: []
 
@@ -108,5 +111,5 @@ rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: Lookup table macro for ActiveRecords
-test_files: []
-
+test_files: 
+- test/test_lookup.rb

data/Manifest

@@ -1,4 +0,0 @@
-README
-Rakefile
-lib/active_record/lookup.rb
-Manifest