rails_lookup 0.0.3 → 0.0.4

data/.gitignore

@@ -0,0 +1,9 @@
+pkg
+doc
+Manifest
+*.sw*
+test/test.sqlite3
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails_lookup.gemspec
+gemspec

data/README

@@ -140,3 +140,16 @@ I'll let you work out the details for actually migrating the data yourself.
 
 I hope this helped you and saved a lot of time and frustration. Follow me on twitter: @nimrodpriell
 
+TESTING
+-------
+
+    rvm gemset create rails_lookup_devel
+    gem install bundler
+    bundle install
+    rake test
+
+That should basically do it. The gems required are managed in the Gemfile, they
+are currently Rails and SQLite (which is used only for testing). This has been
+tested to work with rails-3.0.9
+
+

data/Rakefile

@@ -1,29 +1,8 @@
-require 'rubygems'  
-require 'rake'  
-require 'echoe'  
-  
-Echoe.new('rails_lookup', '0.0.3') 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/"
-  s.author      = "Nimrod Priell"
-  s.email       = "@nimrodpriell" #Twitter
-  s.ignore_pattern  = ["tmp/*", "script/*", "Manifest"]  
-  s.development_dependencies = []  
-end  
-  
-Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }  
-=begin
-spec = Gem::Specification.new do |s|
-  s.name        = "rails_lookup"
-  s.requirements = [ 'Rails >= 3.0.7, Ruby >= 1.9.1' ]
-  s.version     = "0.0.1"
-  s.homepage    = ""
-  s.platform    = "Gem::Platform::RUBY"
-  s.required_ruby_version = '>=1.9' 
-  s.files = Dir['**/**'] 
-  s.executables = [] 
-  s.test_files = [] #Dir["test/test*.rb"] 
-  s.has_rdoc = false
-end 
-=end
+require 'bundler/gem_tasks'
+
+# Adapted from matthewtodd's shoe gem at https://github.com/matthewtodd/shoe
+desc "Runs all tests for the gem"
+task :test do
+  spec = Gem::Specification.load(Dir.glob('*.gemspec')[0])
+  system('testrb', *spec.test_files) || exit(1)
+end

data/lib/rails_lookup.rb

@@ -0,0 +1,163 @@
+require 'rails_lookup/version'
+require 'active_record/base'
+require 'active_record/relation'
+
+# Author: Nimrod Priell (Twitter: @nimrodpriell)
+# 
+# See README file or blog post for more.
+# This is intended to be included into ActiveRecord entities: Simply
+# include ActiveRecord::Lookup
+# in your class that extends ActiveRecord::Base
+module RailsLookup
+  #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
+
+          def self.gen_id_for(val)
+            id = id_for val
+            if id.nil?
+              #Define this new possible value
+              #You could just override this...
+              new_db_obj = find_or_create_by_name val 
+              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
+
+        Object.const_set lookup_cls_name, cls #Define it as a global class
+      end
+
+
+      define_method("#{as_name.to_s}_id=") do |id|
+        write_attribute "#{as_name.to_s}".to_sym, id
+      end
+
+      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_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}".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
+
+
+      #Rails ActiveRecord support:
+      @cls_for_name = {} if @cls_for_name.nil?
+      @cls_for_name[as_name.to_s.to_sym] = cls
+
+      #This makes find_and_create_by, find_all and where methods all work as
+      #they should. This will not work if you use reset_column_information,
+      #like if you use find_by_session_id in SessionStore. You must redefine
+      #it so it re-sets rel to this singleton object
+      rel = ActiveRecord::Relation.new(self, arel_table)
+      def rel.where(opts, *rest)
+        if opts.is_a? Hash
+          mapped = opts.map do |k,v| 
+            if @cls_for_name.has_key?(k.to_sym) 
+              [k, @cls_for_name[k.to_sym].id_for(v)] 
+            else
+              [k, v] 
+            end
+          end
+          opts = Hash[mapped]
+        end
+        super(opts, *rest)
+      end
+
+      def rel.cls_for_name=(cls_for_name)
+        @cls_for_name = cls_for_name
+      end
+
+      rel.cls_for_name = @cls_for_name
+      instance_variable_set(:@relation, rel)
+
+      #Might need to be in class_eval
+      belongs_to lookup_name.to_s.to_sym, :foreign_key => "#{as_name}"
+      validates as_name.to_s.to_sym, :presence => true
+
+      # Prefill the hashes from the DB - requires an active connection
+      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
+
+  end
+
+  # extend host class with class methods when we're included 
+  def self.included(host_class)
+    host_class.extend(ClassMethods) 
+  end
+end
+

data/lib/rails_lookup/version.rb

@@ -0,0 +1,3 @@
+module RailsLookup
+  VERSION = "0.0.4"
+end

data/rails_lookup.gemspec

@@ -1,172 +1,28 @@
 # -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rails_lookup/version"
 
 Gem::Specification.new do |s|
-  s.name = %q{rails_lookup}
-  s.version = "0.0.3"
+  s.name        = %q{rails_lookup}
+  s.version     = RailsLookup::VERSION
+  s.authors     = ["Nimrod Priell"]
+  s.email       = ["nimrod.priell@gmail.com"]
+  s.homepage    = %q{http://github.com/Nimster/RailsLookup/}
+  s.summary     = %q{Lookup table macro for ActiveRecords. See more in the README}
+
+  s.rubyforge_project = %q{rails_lookup}
 
   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-09}
-  s.description = %q{Lookup tables with ruby-on-rails
---------------------------------
-
-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
-----------
-
-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 
-ID          | car_name        | car_type
-1           | Chevrolet Aveo  | Compact
-2           | Ford Fiesta     | Compact
-3           | BMW Z-5         | Sports
-
-You want to have two tables:
-ID  | car_name        | car_type_id
-1   | Chevrolet Aveo  | 1
-2   | Ford Fiesta     | 1
-3   | BMW Z-5         | 2
-
-And
-
-car_type_id | car_type_name 
-1           | Compact
-2           | Sports
-
-The pros/cons of a normalized DB can be discussed elsewhere. I'd just point out a denormalized solution is most useful in settings like [column oriented DBMSes][2]. For the rest of us folks using standard databases, we usually want to use lookups.
-
-The usual way to do this with ruby on rails is
-* Generate a CarType model using `rails generate model CarType name:string`
-* Link between CarType and Car tables using `belongs_to` and `has_many`
-
-Then to work with this you can transparently read the car type:
-
-    car = Car.all.first
-    car.car_type.name # returns "Compact"
-
-Ruby does an awesome job of caching the results for you, so that you'll probably not hit the DB every time you get the same car type from different car objects.
-
-You can even make this shorter, by defining a delegate to car_type_name from CarType:
-
-*in car_type_name.rb*
-    
-    delegate :name, :to => :car, :prefix => true
-
-And now you can access this as 
-
-    car.car_type_name
-
-However, it's less pleasant to insert with this technique:
-
-    car.car_type.car_type_name = "Sports"
-    car.car_type.save!
-    #Now let's see what happened to the OTHER compact car
-    Car.all.second.car_type_name #Oops, returns "Sports"
-
-Right, what are we doing? We should've used
-
-    car.update_attributes(car_type: CarType.find_or_create_by_name(name: "Sports"))
-
-Okay. Probably want to shove that into its own method rather than have this repeated in the code several times. But you also need a helper method for creating cars that way…
-
-Furthermore, ruby is good about caching, but it caches by the exact query used, and the cache expires after the controller action ends. You can configure more advanced caches, perhaps.
-
-The thing is all this can get tedious if you use a normalized structure where you have 15 entities and each has at least one 'type-like' field. That's a whole lot of dangling Type objects. What you really want is an interface like this:
-
-    car.all.first
-    car.car_type #return "Compact"
-    car.car_type = "Sports" #No effect on car.all.second, just automatically use the second constant
-    car.car_type = "Sedan" #Magically create a new type
-
-Oh, and it'll be nice if all of this is cached and you can define car types as constants (or symbols). You obviously still want to be able to run:
-
-    CarType.where (:id > 3) #Just an example of supposed "arbitrary" SQL involving a real live CarType class
-
-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?
-
-I've looked thoroughly for a nice rails solution to this, but after failing to find one, I created my own rails metaprogramming hook.
-
-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
-
-    require 'active_record/lookup'
-    class Car < ActiveRecord::Base
-      #...
-      include ActiveRecord::Lookup
-      lookup :car_type
-      #...
-    end
-
-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
-
-    CarType.id_for "Sports" #Returns 2
-    CarType.name_for 1 #Returns "Compact"
-
-and you can still hack at the underlying ID for an object, if you need to:
-
-    car = car.all.first
-    car.car_type = "Sports"
-    car.car_type_id #Returns 2
-    car.car_type_id = 1
-    car.car_type #Returns "Compact"
-
-The only remaining thing is to define your migrations for creating the actual database tables. After all, that's something you only want to do once and not every time this class loads, so this isn't the place for it. However, it's easy enough to create your own scaffolds so that 
-
-     rails generate migration create_car_type_lookup_for_car
-
-will automatically create the migration
-
-    class CreateCarTypeLookupForCar < ActiveRecord::Migration
-      def self.up
-        create_table :car_types do |t|
-          t.string :name
-          t.timestamps #Btw you can remove these, I don't much like them in type tables anyway
-        end
-    
-        remove_column :cars, :car_type #Let's assume you have one of those now…
-        add_column :cars, :car_type_id, :integer #Maybe put not_null constraints here.
-      end
-
-      def self.down
-        drop_table :car_types
-        add_column :cars, :car_type, :string
-        remove_column :cars, :car_type_id
-      end
-    end
-
-I'll let you work out the details for actually migrating the data yourself. 
-
-[1] http://en.wikipedia.org/wiki/Database_normalization
-[2] http://en.wikipedia.org/wiki/Column-oriented_DBMS
-
-I hope this helped you and saved a lot of time and frustration. Follow me on twitter: @nimrodpriell
-
-}
-  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{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}]
+  s.description = %q{Lookup tables with ruby-on-rails}
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*_test.rb`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.extra_rdoc_files = [%q{README}, %q{lib/rails_lookup.rb}]
+  s.rdoc_options = [%q{--line-numbers}, %q{--inline-source}, %q{--title}, %q{rails_lookup}, %q{--main}, %q{README}]
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  s.add_dependency 'rails'
+  s.add_development_dependency 'sqlite3'
 end

data/test/{test_lookup.rb → lookup_test.rb}

@@ -1,18 +1,44 @@
-require 'lookup'
+require 'active_record'
+$:.push File.expand_path('lib')
+#$:.push File.expand_path('../lib', __FILE__)
+require 'rails_lookup'
 require 'minitest/autorun'
+require '20110808002412_create_test_lookup_db'
+
+# It sucks we have to do that in testing code, but I have to establish a
+# connection prior to defining any classes that use lookups, and I see no other
+# way around it other than extracting the test classes and requiring them only
+# after the connection is established in setup() - which might be a nice
+# solution but muddles things up.
+# Establish a connection to the test database:
+conn = ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3", 
+  database: "test/test.sqlite3",
+  pool: 5,
+  timeout: 5000
+)
+puts "Established connection!" unless conn.nil?
+CreateTestLookupDb.migrate(:down) # Connection has to be established for this to work
+CreateTestLookupDb.migrate(:up)
 
 class Car < ActiveRecord::Base
-  include Lookup
+  include RailsLookup
   lookup :car_kind, :as => :kind
   lookup :car_color, :as => :color
+
+  # Example of how to scope for lookups
+  scope :by_color, lambda { |color| 
+    joins(:car_color)\
+      .where({:car_colors => { name: color }})
+  }
 end
 
 class Plane < ActiveRecord::Base
-  include Lookup
+  include RailsLookup
   lookup :plane_kind, :as => :kind
 end
 
-class TestLookup < MiniTest::Unit::TestCase
+class LookupTest < MiniTest::Unit::TestCase
 
   def setup
     clear_tables
@@ -23,6 +49,9 @@ class TestLookup < MiniTest::Unit::TestCase
   end
 
   def clear_tables
+    # In every test you ever do, these calls will be required for all lookup
+    # tables involved, since they take care of clearing the (static) caches.
+    # Otherwise, you'd have a stale cache in the lookup class.
     Car.delete_all
     CarKind.delete_all
     CarColor.delete_all
@@ -129,11 +158,13 @@ class TestLookup < MiniTest::Unit::TestCase
     assert_equal "Yellow", bimba2.color
     assert_equal "Compact", bimba2.kind
     cars_before_creation = Car.count
-    susita = Car.find_or_create_by_name_and_kind_and_color "Susita", "Compact", "Gray"
+    susita = Car.find_or_create_by_name_and_kind_and_color(\
+        "Susita", "Compact", "Gray")
     assert_equal "Gray", susita.color
     assert_equal "Compact", susita.kind
     assert_equal cars_before_creation + 1, Car.count
-    bimba2 = Car.find_or_create_by_name_and_kind_and_color "Bimba", "Compact", "Yellow"
+    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
@@ -179,7 +210,7 @@ class TestLookup < MiniTest::Unit::TestCase
     #We get a new CarKind class - but this one will be preloaded
     tmp = CarKind
     Class.new(ActiveRecord::Base) do
-      include Lookup
+      include RailsLookup
       lookup :car_kind
     end
     refute_nil CarKind.id_for("Compact")
@@ -208,40 +239,13 @@ class TestLookup < MiniTest::Unit::TestCase
 #    yellow = CarColor.find_by_name "Yellow"
 #    assert_equal 2, yellow.cars.size
   end
+
+  # TODO: Test a scope
+  def test_scopes
+    bimba = Car.create! :name => "Bimba", :kind => "Compact", :color => "Yellow"
+    ferrari = Car.create! :kind => "Sports", :color => "Red"
+    assert_equal 1, Car.by_color("Yellow").count 
+    assert_equal 1, Car.by_color("Red").count
+  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

@@ -1,115 +1,86 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: rails_lookup
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 0.0.4
   prerelease: 
-  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Nimrod Priell
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-08-09 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\
-  ID          | car_name        | car_type\n\
-  1           | Chevrolet Aveo  | Compact\n\
-  2           | Ford Fiesta     | Compact\n\
-  3           | BMW Z-5         | Sports\n\n\
-  You want to have two tables:\n\
-  ID  | car_name        | car_type_id\n\
-  1   | Chevrolet Aveo  | 1\n\
-  2   | Ford Fiesta     | 1\n\
-  3   | BMW Z-5         | 2\n\n\
-  And\n\n\
-  car_type_id | car_type_name \n\
-  1           | Compact\n\
-  2           | Sports\n\n\
-  The pros/cons of a normalized DB can be discussed elsewhere. I'd just point out a denormalized solution is most useful in settings like [column oriented DBMSes][2]. For the rest of us folks using standard databases, we usually want to use lookups.\n\n\
-  The usual way to do this with ruby on rails is\n\
-  * Generate a CarType model using `rails generate model CarType name:string`\n\
-  * Link between CarType and Car tables using `belongs_to` and `has_many`\n\n\
-  Then to work with this you can transparently read the car type:\n\n    car = Car.all.first\n    car.car_type.name # returns \"Compact\"\n\n\
-  Ruby does an awesome job of caching the results for you, so that you'll probably not hit the DB every time you get the same car type from different car objects.\n\n\
-  You can even make this shorter, by defining a delegate to car_type_name from CarType:\n\n\
-  *in car_type_name.rb*\n    \n    delegate :name, :to => :car, :prefix => true\n\n\
-  And now you can access this as \n\n    car.car_type_name\n\n\
-  However, it's less pleasant to insert with this technique:\n\n    car.car_type.car_type_name = \"Sports\"\n    car.car_type.save!\n    #Now let's see what happened to the OTHER compact car\n    Car.all.second.car_type_name #Oops, returns \"Sports\"\n\n\
-  Right, what are we doing? We should've used\n\n    car.update_attributes(car_type: CarType.find_or_create_by_name(name: \"Sports\"))\n\n\
-  Okay. Probably want to shove that into its own method rather than have this repeated in the code several times. But you also need a helper method for creating cars that way\xE2\x80\xA6\n\n\
-  Furthermore, ruby is good about caching, but it caches by the exact query used, and the cache expires after the controller action ends. You can configure more advanced caches, perhaps.\n\n\
-  The thing is all this can get tedious if you use a normalized structure where you have 15 entities and each has at least one 'type-like' field. That's a whole lot of dangling Type objects. What you really want is an interface like this:\n\n    car.all.first\n    car.car_type #return \"Compact\"\n    car.car_type = \"Sports\" #No effect on car.all.second, just automatically use the second constant\n    car.car_type = \"Sedan\" #Magically create a new type\n\n\
-  Oh, and it'll be nice if all of this is cached and you can define car types as constants (or symbols). You obviously still want to be able to run:\n\n    CarType.where (:id > 3) #Just an example of supposed \"arbitrary\" SQL involving a real live CarType class\n\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\
-  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\
-  and you can still hack at the underlying ID for an object, if you need to:\n\n    car = car.all.first\n    car.car_type = \"Sports\"\n    car.car_type_id #Returns 2\n    car.car_type_id = 1\n    car.car_type #Returns \"Compact\"\n\n\
-  The only remaining thing is to define your migrations for creating the actual database tables. After all, that's something you only want to do once and not every time this class loads, so this isn't the place for it. However, it's easy enough to create your own scaffolds so that \n\n     rails generate migration create_car_type_lookup_for_car\n\n\
-  will automatically create the migration\n\n    class CreateCarTypeLookupForCar < ActiveRecord::Migration\n      def self.up\n        create_table :car_types do |t|\n          t.string :name\n          t.timestamps #Btw you can remove these, I don't much like them in type tables anyway\n        end\n    \n        remove_column :cars, :car_type #Let's assume you have one of those now\xE2\x80\xA6\n        add_column :cars, :car_type_id, :integer #Maybe put not_null constraints here.\n      end\n\n      def self.down\n        drop_table :car_types\n        add_column :cars, :car_type, :string\n        remove_column :cars, :car_type_id\n      end\n    end\n\n\
-  I'll let you work out the details for actually migrating the data yourself. \n\n\
-  [1] http://en.wikipedia.org/wiki/Database_normalization\n\
-  [2] http://en.wikipedia.org/wiki/Column-oriented_DBMS\n\n\
-  I hope this helped you and saved a lot of time and frustration. Follow me on twitter: @nimrodpriell\n\n"
-email: "@nimrodpriell"
+date: 2011-08-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70313073195380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70313073195380
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70313073194820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70313073194820
+description: Lookup tables with ruby-on-rails
+email:
+- nimrod.priell@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README
-- lib/active_record/lookup.rb
-files: 
+- lib/rails_lookup.rb
+files:
+- .gitignore
+- Gemfile
 - README
 - Rakefile
-- lib/active_record/lookup.rb
+- lib/rails_lookup.rb
+- lib/rails_lookup/version.rb
+- rails_lookup-0.0.3.gem
 - rails_lookup.gemspec
 - test/20110808002412_create_test_lookup_db.rb
-- test/test_lookup.rb
+- test/lookup_test.rb
 homepage: http://github.com/Nimster/RailsLookup/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - --line-numbers
 - --inline-source
 - --title
-- Rails_lookup
+- rails_lookup
 - --main
 - README
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "1.2"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.2'
 requirements: []
-
 rubyforge_project: rails_lookup
-rubygems_version: 1.8.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: Lookup table macro for ActiveRecords
-test_files: 
-- test/test_lookup.rb
+summary: Lookup table macro for ActiveRecords. See more in the README
+test_files:
+- test/lookup_test.rb

data/lib/active_record/lookup.rb

@@ -1,153 +0,0 @@
-# Author: Nimrod Priell (Twitter: @nimrodpriell)
-# 
-# See README file or blog post for more.
-# This is intended to be included into ActiveRecord entities: Simply
-# include ActiveRecord::Lookup
-# in your class that extends ActiveRecord::Base
-module ActiveRecord
-  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
-
-            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
-
-          Object.const_set lookup_cls_name, cls #Define it as a global class
-        end
-
-
-        define_method("#{as_name.to_s}_id=") do |id|
-          write_attribute "#{as_name.to_s}".to_sym, id
-        end
-
-        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_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}".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
-
-
-        #Rails ActiveRecord support:
-        @cls_for_name = {} if @cls_for_name.nil?
-        @cls_for_name[as_name.to_s.to_sym] = cls
-
-        #This makes find_and_create_by, find_all and where methods all work as
-        #they should. This will not work if you use reset_column_information,
-        #like if you use find_by_session_id in SessionStore. You must redefine
-        #it so it re-sets rel to this singleton object
-        rel = ActiveRecord::Relation.new(self, arel_table)
-        def rel.where(opts, *rest)
-          if opts.is_a? Hash
-            mapped = opts.map { |k,v| @cls_for_name.has_key?(k.to_sym) ? [k, @cls_for_name[k.to_sym].id_for(v)] : [k, v] }
-            opts = Hash[mapped]
-          end
-          super(opts, *rest)
-        end
-
-        def rel.cls_for_name=(cls_for_name)
-          @cls_for_name = cls_for_name
-        end
-
-        rel.cls_for_name = @cls_for_name
-        instance_variable_set(:@relation, rel)
-
-        #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
-
-    end
-
-    # extend host class with class methods when we're included 
-    def self.included(host_class)
-      host_class.extend(ClassMethods) 
-    end
-  end
-end