lookup_by 0.1.0

data/lib/lookup_by/hooks/simple_form.rb

@@ -0,0 +1,27 @@
+require "active_support/concern"
+
+module LookupBy
+  module Hooks
+    module SimpleForm
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :input, :lookup
+      end
+
+      def input_with_lookup(method, options = {}, &block)
+        klass = object.class
+
+        if klass.respond_to?(:lookups) && klass.lookups.include?(method.to_sym)
+          target = method.to_s.classify.constantize
+
+          options[:collection] ||= target.pluck(target.lookup.field) if target.lookup.cache_all?
+        end
+
+        input_without_lookup(method, options, &block)
+      end
+    end
+  end
+end
+
+::SimpleForm::FormBuilder.send :include, LookupBy::Hooks::SimpleForm

data/lib/lookup_by/lookup.rb

@@ -0,0 +1,113 @@
+module LookupBy
+  module Lookup
+    module MacroMethods
+      def is_a_lookup?
+        is_a? LookupBy::Lookup::ClassMethods
+      end
+
+      def lookup_by(field, options = {})
+        options.symbolize_keys!
+        options.assert_valid_keys :order, :cache, :normalize, :find, :find_or_create, :raise
+
+        raise "#{self} already uses lookup_by" if is_a? LookupBy::Lookup::ClassMethods
+        raise "#{self} responds_to :[], needed for lookup_by"     if respond_to? :[]
+        raise "#{self} responds_to :lookup, needed for lookup_by" if respond_to? :lookup
+
+        extend ClassMethods
+
+        class_eval do
+          include InstanceMethods
+
+          class << self; attr_reader :lookup; end
+
+          # validates field, presence: true, uniqueness: true
+
+          unless field == :name || column_names.include?("name")
+            alias_attribute :name, field
+
+            attr_accessible :name if respond_to?(:accessible_attributes) && accessible_attributes.include?(field)
+          end
+
+          @lookup = Cache.new(self, options.merge(field: field))
+          @lookup.reload
+        end
+      end
+    end
+
+    module ClassMethods
+      def all
+        return super if @lookup.read_through?
+
+        @lookup.cache.values
+      end
+
+      def count(column_name = nil, options = {})
+        return super if @lookup.read_through?
+        return super if column_name
+
+        @lookup.cache.size
+      end
+
+      def pluck(column_name)
+        return super if @lookup.read_through?
+
+        @lookup.cache.values.map { |o| o.send(column_name) }
+      end
+
+      def [](arg)
+        case arg
+        when nil, "" then nil
+        when String  then @lookup.fetch(arg)
+        when Symbol  then @lookup.fetch(arg.to_s)
+        when Fixnum  then @lookup.fetch(arg)
+        when self    then arg
+        else raise TypeError, "#{name}[arg]: arg must be a String, Symbol, Fixnum, nil, or #{name}"
+        end
+      end
+    end
+
+    module InstanceMethods
+      def ===(arg)
+        case arg
+        when Symbol, String, Fixnum, nil
+          return self == self.class[arg]
+        when Array
+          return !!arg.detect { |i| self === i }
+        end
+
+        super
+      end
+    end
+
+    module SchemaMethods
+      def create_lookup_table(table_name, options = {})
+        lookup_column = options[:lookup_column] || table_name.to_s.singularize
+        primary_key   = options[:primary_key]   || table_name.to_s.singularize + "_id"
+
+        create_table table_name, primary_key: primary_key do |t|
+          t.text lookup_column, null: false
+
+          yield t if block_given?
+        end
+
+        add_index table_name, lookup_column, unique: true
+      end
+
+      def create_lookup_tables(*table_names)
+        table_names.each do |table_name|
+          create_lookup_table table_name
+        end
+      end
+    end
+
+    module CommandRecorderMethods
+      def create_lookup_table(*args)
+        record(:create_lookup_table, args)
+      end
+
+      def invert_create_lookup_table(args)
+        [:drop_table, [args.first]]
+      end
+    end
+  end
+end

data/lib/lookup_by/railtie.rb

@@ -0,0 +1,20 @@
+require "active_record/railtie"
+
+module LookupBy
+  class Railtie < ::Rails::Railtie
+    initializer "lookup_by" do
+      ActiveSupport.on_load :active_record do
+        extend Lookup::MacroMethods
+        extend Association::MacroMethods
+
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+          include Lookup::SchemaMethods
+        end
+
+        ActiveRecord::Migration::CommandRecorder.class_eval do
+          include Lookup::CommandRecorderMethods
+        end
+      end
+    end
+  end
+end

data/lib/lookup_by/version.rb

@@ -0,0 +1,3 @@
+module LookupBy
+  VERSION = "0.1.0"
+end

data/lib/lookup_by.rb

@@ -0,0 +1,27 @@
+require "lookup_by/version"
+require "lookup_by/railtie" if defined? Rails
+
+module LookupBy
+  class Error < StandardError; end
+
+  autoload :Association, "lookup_by/association"
+  autoload :Cache,       "lookup_by/cache"
+  autoload :Lookup,      "lookup_by/lookup"
+
+  module Caching
+    autoload :LRU,       "lookup_by/caching/lru"
+    autoload :SafeLRU,   "lookup_by/caching/safe_lru"
+  end
+end
+
+begin
+  require "simple_form"
+  require "lookup_by/hooks/simple_form"
+rescue LoadError
+end
+
+begin
+  require "formtastic"
+  require "lookup_by/hooks/formtastic"
+rescue LoadError
+end

data/lookup_by.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+require "lookup_by/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "lookup_by"
+  gem.version     = LookupBy::VERSION
+
+  gem.summary     = %q(A thread-safe lookup table cache for ActiveRecord)
+  gem.description = %q(Use database lookup tables in AR models.)
+
+  gem.authors     = ["Erik Peterson"]
+  gem.email       = ["erik@enova.com"]
+
+  gem.homepage    = "http://www.github.com/companygardener/lookup_by"
+
+  gem.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  gem.files       = `git ls-files`.split("\n")
+  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  gem.add_dependency "rails", ">= 3.0.0"
+end

data/spec/association_spec.rb

@@ -0,0 +1,102 @@
+require "spec_helper"
+require "lookup_by"
+require "pry"
+
+describe ::ActiveRecord::Base do
+  describe "macro methods" do
+    subject { described_class }
+
+    it { should respond_to :lookup_for }
+  end
+
+  describe ".lookup_for" do
+    subject { Address }
+
+    it "doesn't clobber methods" do
+      class << subject
+        public :define_method, :remove_method
+      end
+
+      [:foo, :foo=, :raw_foo, :foo_before_type_cast].each do |method|
+        subject.define_method(method) { }
+
+        expect { subject.lookup_for :foo }.to raise_error LookupBy::Error, /already exists/
+
+        subject.remove_method(method)
+      end
+    end
+
+    it "requires a foreign key" do
+      expect { subject.lookup_for :missing }.to raise_error LookupBy::Error, /foreign key/
+    end
+
+    it "rejects unsaved lookup values" do
+      expect { subject.new.city = City.new(name: "Toronto") }.to raise_error ArgumentError, /must be saved/
+    end
+  end
+end
+
+describe LookupBy::Association do
+  before do
+    City.create(name: "New York")
+  end
+
+  after do
+    City.delete_all
+  end
+
+  subject { Address.new }
+
+  context "Address.lookup_for :city, strict: false" do
+    it_behaves_like "a lookup for", :city
+
+    it "accepts Fixnums" do
+      subject.city = City.where(city: "New York").first.id
+      subject.city.should eq "New York"
+    end
+
+    it "rejects symbols" do
+      expect { subject.city = :'New York' }.to raise_error ArgumentError
+    end
+
+    it "returns strings" do
+      subject.city = "New York"
+      subject.city.should eq "New York"
+    end
+
+    it "allows missing values" do
+      subject.city = "Chicago"
+      subject.city.should be_nil
+    end
+  end
+
+  context "Address.lookup_for :state, symbolize: true" do
+    it_behaves_like "a lookup for", :state
+
+    it "allows symbols" do
+      subject.state = :AL
+      subject.state.should eq :AL
+    end
+
+    it "returns symbols" do
+      subject.state = "AL"
+      subject.state.should eq :AL
+    end
+
+    it "rejects missing values" do
+      expect { subject.state = "FOO" }.to raise_error LookupBy::Error, /not in the .* lookup cache/
+    end
+  end
+
+  context "Address.lookup_for :street" do
+    it "accepts write-through values" do
+      expect { subject.street = "Dearborn Street" }.to change(Street, :count)
+    end
+  end
+
+  context "Missing.lookup_for :city" do
+    it "does not raise foreign key error when table hasn't been created" do
+      expect { require "missing"; }.to_not raise_error
+    end
+  end
+end

data/spec/caching/lru_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+require "lookup_by/caching/lru"
+
+include LookupBy::Caching
+
+module LookupBy::Caching
+  describe LRU do
+    before(:each) do
+      @cache = LRU.new(2)
+
+      @cache[1] = "one"
+      @cache[2] = "two"
+    end
+
+    subject { @cache }
+
+    it "stores entries" do
+      @cache[1].should eq "one"
+      @cache[2].should eq "two"
+    end
+
+    it "drops oldest" do
+      @cache[3] = "three"
+
+      @cache[1].should be_nil
+    end
+
+    it "keeps gets" do
+      @cache[1]
+      @cache[3] = "three"
+
+      @cache[1].should eq "one"
+      @cache[2].should be_nil
+      @cache[3].should eq "three"
+    end
+
+    it "keeps sets" do
+      @cache[1] = "one"
+      @cache[3] = "three"
+
+      @cache[1].should eq "one"
+      @cache[2].should be_nil
+      @cache[3].should eq "three"
+    end
+
+    it "#clear" do
+      cache = LRU.new(2)
+
+      cache[1] = "one"
+      cache.size.should eq 1
+      cache.clear
+      cache.size.should eq 0
+    end
+
+    specify "#merge" do
+      @cache.merge(1 => "change", 3 => "three").should
+        eq(1 => "change", 2 => "two", 3 => "three")
+    end
+
+    specify "#merge!" do
+      cache = LRU.new(3)
+
+      cache[1] = "one"
+      cache[2] = "two"
+
+      cache.merge!(1 => "change", 3 => "three")
+      cache.should eq(1 => "change", 2 => "two", 3 => "three")
+    end
+
+    its(:to_h) { should eq(1 => "one", 2 => "two") }
+  end
+end

data/spec/dummy/.rspec

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

data/spec/dummy/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec) do |config|
+  config.pattern = FileList["../**/*_spec.rb"]
+end
+
+task :default => :spec

data/spec/dummy/app/models/account.rb

@@ -0,0 +1,5 @@
+class Account < ActiveRecord::Base
+  attr_accessible :account
+
+  lookup_by :account, cache: true, find: true
+end

data/spec/dummy/app/models/address.rb

@@ -0,0 +1,6 @@
+class Address < ActiveRecord::Base
+  lookup_for :city, strict: false
+  lookup_for :state, symbolize: true
+  lookup_for :postal_code
+  lookup_for :street
+end

data/spec/dummy/app/models/city.rb

@@ -0,0 +1,5 @@
+class City < ActiveRecord::Base
+  attr_accessible :city
+
+  lookup_by :city
+end

data/spec/dummy/app/models/email_address.rb

@@ -0,0 +1,5 @@
+class EmailAddress < ActiveRecord::Base
+  attr_accessible :email_address
+
+  lookup_by :email_address, find_or_create: true
+end

data/spec/dummy/app/models/ip_address.rb

@@ -0,0 +1,5 @@
+class IpAddress < ActiveRecord::Base
+  attr_accessible :ip_address
+
+  lookup_by :ip_address, cache: 2, find_or_create: true
+end

data/spec/dummy/app/models/postal_code.rb

@@ -0,0 +1,5 @@
+class PostalCode < ActiveRecord::Base
+  attr_accessible :postal_code
+
+  lookup_by :postal_code, cache: 2
+end

data/spec/dummy/app/models/state.rb

@@ -0,0 +1,5 @@
+class State < ActiveRecord::Base
+  attr_accessible :state
+
+  lookup_by :state, cache: true
+end

data/spec/dummy/app/models/status.rb

@@ -0,0 +1,9 @@
+class Status < ActiveRecord::Base
+  attr_accessible :status
+
+  lookup_by :status, normalize: true
+
+  def status=(arg)
+    write_attribute :status, arg.strip if arg.respond_to?(:strip)
+  end
+end

data/spec/dummy/app/models/street.rb

@@ -0,0 +1,5 @@
+class Street < ActiveRecord::Base
+  attr_accessible :street
+
+  lookup_by :street, find_or_create: true
+end

data/spec/dummy/config/application.rb

@@ -0,0 +1,20 @@
+require File.expand_path('../boot', __FILE__)
+
+require "active_record/railtie"
+
+Bundler.require
+require "lookup_by"
+
+module Dummy
+  class Application < Rails::Application
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Enforce whitelist mode for mass assignment.
+    # This will create an empty whitelist of attributes available for mass-assignment for all models
+    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
+    # parameters by using an attr_accessible or attr_protected declaration.
+    config.active_record.whitelist_attributes = true
+  end
+end
+

data/spec/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+gemfile = File.expand_path('../../../../Gemfile', __FILE__)
+
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,52 @@
+# PostgreSQL. Versions 8.2 and up are supported.
+#
+# Install the pg driver:
+#   gem install pg
+# On Mac OS X with macports:
+#   gem install pg -- --with-pg-config=/opt/local/lib/postgresql84/bin/pg_config
+# On Windows:
+#   gem install pg
+#       Choose the win32 build.
+#       Install PostgreSQL and put its /bin directory on your path.
+#
+# Configure Using Gemfile
+# gem 'pg'
+#
+development:
+  adapter: postgresql
+  encoding: unicode
+  database: lookup_by_development
+  pool: 5
+  username: dummy
+  password:
+
+  # Connect on a TCP socket. Omitted by default since the client uses a
+  # domain socket that doesn't need configuration. Windows does not have
+  # domain sockets, so uncomment these lines.
+  #host: localhost
+  #port: 5432
+
+  # Schema search path. The server defaults to $user,public
+  #schema_search_path: myapp,sharedapp,public
+
+  # Minimum log levels, in increasing order:
+  #   debug5, debug4, debug3, debug2, debug1,
+  #   log, notice, warning, error, fatal, and panic
+  # The server defaults to notice.
+  #min_messages: warning
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: postgresql
+  database: lookup_by_test
+  username: postgres
+
+production:
+  adapter: postgresql
+  encoding: unicode
+  database: dummy_production
+  pool: 5
+  username: dummy
+  password:

data/spec/dummy/config/environment.rb

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

data/spec/dummy/config/environments/development.rb

@@ -0,0 +1,15 @@
+Dummy::Application.configure do
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Raise exception on mass assignment protection for Active Record models
+  config.active_record.mass_assignment_sanitizer = :strict
+end

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

@@ -0,0 +1,16 @@
+Dummy::Application.configure do
+  # The test environment is used exclusively to run your application's
+  # test suite. You never need to work with it otherwise. Remember that
+  # your test database is "scratch space" for the test suite and is wiped
+  # and recreated between test runs. Don't rely on the data there!
+  config.cache_classes = true
+
+  # Log error messages when you accidentally call methods on nil
+  config.whiny_nils = true
+
+  # Raise exception on mass assignment protection for Active Record models
+  config.active_record.mass_assignment_sanitizer = :strict
+
+  # Print deprecation notices to the stderr
+  config.active_support.deprecation = :stderr
+end

data/spec/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application

data/spec/dummy/db/migrate/20121019040009_create_tables.rb

@@ -0,0 +1,23 @@
+class CreateTables < ActiveRecord::Migration
+  def up
+    create_lookup_tables :cities, :states, :postal_codes, :streets
+
+    create_lookup_table :ip_addresses
+    create_lookup_table :email_addresses
+
+    create_lookup_table :accounts
+    create_lookup_table :statuses
+
+    create_table :addresses, primary_key: "address_id" do |t|
+      t.belongs_to :city
+      t.belongs_to :state
+      t.belongs_to :postal_code
+      t.belongs_to :street
+    end
+
+    State.create(name: "AL")
+  end
+
+  def down
+  end
+end