acts_as_lookup 0.1.0 → 0.2.0

data/README.rdoc

@@ -42,9 +42,34 @@ TODO: probably won't work yet...at least need to add an _id attribute to the ass
 
 Some work is yet to be done to support general classes using acts_as_lookup
 
-== Configuration acts_as_lookup
+== Configuration
 
-TODO: go through the options (enabled and FUTURE)
++acts_as_lookup+ accepts an options hash with one required key: +:values+, which is
+an array of hashes that contain lookup data (see above).
+
+Other options available:
+
+==== +:sync_with_db+
+
+Fetches existing records from the db and merges them into the cached values (default true).
+
+==== +:write_to_db+
+
+Writes any missing values to the db (default true).
+
+==== +:add_query_methods+
+
+Defines query methods on instances of the lookup model for checking the identity of a value (default false). For example:
+
+  def Status < ActiveRecord::Base
+    VALS = [ { :id => 1, :name => "active", },
+             { :id => 2, :name => "disabled", }
+           ]
+    acts_as_lookup :values => VALS, :add_query_methods => true
+  end
+
+  Status.active.active? # => true
+  Status.active.disabled? # => false
 
 == Development
 

data/TODO

@@ -1,5 +1,6 @@
 Things to work on:
 
+* TESTING: commented out rspec gem in Rakefile...need to resurrect to reenable testing! May just need to specify rspec version, but would probably be good to bring up to date. :(
 
 * 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.

data/acts_as_lookup.gemspec

@@ -1,44 +1,33 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{acts_as_lookup}
-  s.version = "0.1.0"
+  s.name = "acts_as_lookup"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Brian Percival"]
-  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{percivalatdiscovereadsdotcom}
+  s.date = "2012-07-31"
+  s.description = "Provides an easy means for creating models that act like enumerations or lookup\ntables. You can specify the lookup values in your Rails models and can lazily\npush these to the associated db tables (or not). Also dynamically adds helpful\nclass-level methods to access singleton instances of each value in your lookup\ntable.\n"
+  s.email = "percivalatdiscovereadsdotcom"
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc",
-     "TODO"
+    "README.rdoc",
+    "TODO"
   ]
   s.files = [
     "README.rdoc",
-     "acts_as_lookup.gemspec",
-     "lib/acts_as_lookup.rb"
+    "acts_as_lookup.gemspec",
+    "lib/acts_as_lookup.rb"
   ]
-  s.homepage = %q{http://github.com/bmpercy/acts_as_lookup}
-  s.rdoc_options = ["--charset=UTF-8"]
+  s.homepage = "http://github.com/bmpercy/acts_as_lookup"
   s.require_paths = ["lib"]
-  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"
-  ]
+  s.rubygems_version = "1.8.15"
+  s.summary = "Helpful for creating lookup-table-like models"
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/lib/acts_as_lookup.rb

@@ -60,6 +60,9 @@ module ActsAsLookupClassMethods
       # FUTURE: allow for a different column to be used for generating class
       #         accessor methods
       @acts_as_lookup_by_name.each_pair do |name,val|
+        if acts_as_lookup_options[:add_query_methods]
+          self.acts_as_lookup_add_query_method name
+        end
         self.acts_as_lookup_add_shortcut name
       end
 
@@ -123,30 +126,51 @@ module ActsAsLookupClassMethods
   # adds a class method to access a particular lookup value via a shortcut
   # method
   #
+  # FUTURE: will allow for any column to be used here; for now, hardcoded
+  #       to lookup by name
+  #-----------------------------------------------------------------------------
+  def acts_as_lookup_add_shortcut(name)
+    method_name = get_method_name(name)
+    if respond_to?(method_name.to_sym)
+      raise "Cannot create method '#{method_name}' to #{self.inspect} " +
+            "as it conflicts with existing method with same name"
+    end
+
+    instance_eval "def #{method_name}; self.lookup_by_name '#{name}'; end"
+  end
+
+  # adds an instance method of the form [lookup_value_name]? to check the
+  # identity of a lookup object
+  #-----------------------------------------------------------------------------
+  def acts_as_lookup_add_query_method(lookup_name)
+    method_name = "#{get_method_name(lookup_name)}?"
+    if respond_to?(method_name.to_sym)
+      raise "Cannot create method '#{method_name}?' to #{self.inspect} " +
+            "as it conflicts with existing method with same name"
+    end
+
+    define_method(method_name) { self.name == lookup_name }
+  end
+
+  private
+
   # does the following transformations:
   #  - converts spaces to underscores
   #  - downcases entire method name unless the constant is already all caps,
   #    in which case, leaves method name in all caps
   #  - checks for name conflicts and raises exception if the shortcut method
   #    name collides with existing method
-  #
-  # FUTURE: will allow for any column to be used here; for now, hardcoded
-  #       to lookup by name
   #-----------------------------------------------------------------------------
-  def acts_as_lookup_add_shortcut(name)
+  def get_method_name(name)
     method_name = name.gsub(/ /, '_')
     unless method_name.upcase == method_name
       method_name.downcase!
     end
-    if respond_to?(method_name.to_sym)
-      raise "Cannot create method '#{method_name}' to #{self.inspect} " +
-            "as it conflicts with existing method with same name"
-    end
-
-    instance_eval "def #{method_name}; self.lookup_by_name '#{name}'; end"
+    method_name
   end
 end
 
+
 # modify object to allow any class to act like a lookup class
 #------------------------------------------------------------------------------
 class Object
@@ -161,6 +185,7 @@ class Object
 
     options.merge!(:sync_with_db => true) unless options.include?(:sync_with_db)
     options.merge!(:write_to_db => true) unless options.include?(:write_to_db)
+    options.merge!(:add_query_methods => false) unless options.include?(:add_query_methods)
 # FUTURE:
 #                           :remove_from_db => false,
 #                           :shortcut_method_column => :name
@@ -219,8 +244,15 @@ if defined?(ActiveRecord)
       # 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....
+      rails_root = nil
+      begin
+        rails_root = Rails.root
+      rescue
+      end
+      # fallback for Rails 2
+      rails_root ||= RAILS_ROOT if defined?(RAILS_ROOT)
       if !Object.const_defined?(cname)
-        require File.join(RAILS_ROOT, 'app', 'models', cname.underscore)
+        require File.join(rails_root, 'app', 'models', cname.underscore)
       end
     end
   end

metadata

@@ -1,82 +1,63 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: acts_as_lookup
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Brian Percival
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-23 00:00:00 -08:00
-default_executable: 
+date: 2012-07-31 00:00:00.000000000 Z
 dependencies: []
+description: ! 'Provides an easy means for creating models that act like enumerations
+  or lookup
 
-description: |
-  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.
 
+'
 email: percivalatdiscovereadsdotcom
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - LICENSE
 - README.rdoc
 - TODO
-files: 
+files:
 - README.rdoc
 - acts_as_lookup.gemspec
 - 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: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+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 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: Helpful for creating lookup-table-like models
-test_files: 
-- spec/acts_as_lookup_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/spec/acts_as_lookup_spec.rb

@@ -1,436 +0,0 @@
-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

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