has_normalized_sti 1.0.0

data/Gemfile

@@ -0,0 +1,14 @@
+source :rubygems
+
+group :development do
+  gem 'jeweler'
+  gem 'mocha'
+  gem 'i18n'
+end
+
+group :test do
+  gem 'rspec'
+  gem 'rspec-rails'
+  gem 'activerecord', '~> 3.0.0'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,75 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionpack (3.0.8)
+      activemodel (= 3.0.8)
+      activesupport (= 3.0.8)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.8)
+      activesupport (= 3.0.8)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.8)
+      activemodel (= 3.0.8)
+      activesupport (= 3.0.8)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.8)
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mocha (0.9.12)
+    rack (1.2.3)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    railties (3.0.8)
+      actionpack (= 3.0.8)
+      activesupport (= 3.0.8)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    rspec-rails (2.6.1)
+      actionpack (~> 3.0)
+      activesupport (~> 3.0)
+      railties (~> 3.0)
+      rspec (~> 2.6.0)
+    sqlite3 (1.3.3)
+    thor (0.14.6)
+    tzinfo (0.3.28)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.0)
+  i18n
+  jeweler
+  mocha
+  rspec
+  rspec-rails
+  sqlite3

data/README

@@ -0,0 +1,55 @@
+has_normalized_sti
+==================
+
+This extension will allow Rails STI to work a normalized type column.
+
+For example
+
+  create_table :people, :force => true do |t|
+    t.string  :full_name
+    t.integer :type_id
+  end
+
+  create_table :person_types, :force => true do |t|
+    t.string :type_name
+  end
+
+  class Person < ActiveRecord::Base
+    has_normalized_sti
+  end
+
+  class PersonType < ActiveRecord::Base
+  end
+
+  after calling has_normalized_sti:
+  * type - returns the name of the class of the type just as regular STI
+  * type= - set the type to something specific like regular STI
+  * normal_type - the Type object through the relation
+
+
+Configuration options are:
+  * type_class_name - belong_to this model for the type storage
+    (default: #{class_name}Type)
+  * foreign_key - specifies the column for id of the type (default: type_id)
+  * type_column - specifies the column name for the type string on the types table
+    (default: type_name)
+
+Override example
+
+  create_table :people, :force => true do |t|
+    t.string  :full_name
+    t.integer :special_type_id
+  end
+
+  create_table :person_types, :force => true do |t|
+    t.string :special_person_type
+  end
+
+  class SpecialPerson < ActiveRecord::Base
+    set_table_name :people
+    has_normalized_sti :type_class_name => 'SpecialPersonType', :type_column => 'special_person_type', :foreign_key => 'special_type_id'
+  end
+
+  class SpecialPersonType < ActiveRecord::Base
+    set_table_name :person_types
+  end

data/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name        = 'has_normalized_sti'
+    gem.summary     = 'allows rails STI to work when the type is normalized out'
+    gem.description = <<-DESC
+      has_normalzied_sti expects the model to have a type_id column
+      referencing a types table containg all the possible types.
+      the types table will be auto populated with new types as new
+      subclasses are saved
+    DESC
+    gem.email       = 'kevin@glowacz.info'
+    gem.author      = 'Kevin Glowacz'
+    gem.files.exclude '.rvmrc'
+  end
+rescue LoadError
+  puts 'Jeweler (or a dependency) not available. Install it with: gem install jeweler'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/has_normalized_sti.gemspec

@@ -0,0 +1,59 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{has_normalized_sti}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Kevin Glowacz"]
+  s.date = %q{2011-06-24}
+  s.description = %q{      has_normalzied_sti expects the model to have a type_id column
+      referencing a types table containg all the possible types.
+      the types table will be auto populated with new types as new
+      subclasses are saved
+}
+  s.email = %q{kevin@glowacz.info}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "README",
+    "Rakefile",
+    "VERSION",
+    "has_normalized_sti.gemspec",
+    "init.rb",
+    "lib/has_normalized_sti.rb",
+    "spec/has_normalized_sti_spec.rb",
+    "spec/schema.rb",
+    "spec/spec_helper.rb",
+    "spec/speed_test.rb"
+  ]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{allows rails STI to work when the type is normalized out}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<i18n>, [">= 0"])
+    else
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<i18n>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<i18n>, [">= 0"])
+  end
+end
+

data/init.rb

@@ -0,0 +1 @@
+require 'has_normalized_sti'

data/lib/has_normalized_sti.rb

@@ -0,0 +1,135 @@
+module HasNormalizedSti
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # This extension will allow Rails STI to work a normalized type column.
+
+  # For example
+
+  #   create_table :people, :force => true do |t|
+  #     t.string  :full_name
+  #     t.integer :type_id
+  #   end
+
+  #   create_table :person_types, :force => true do |t|
+  #     t.string :type_name
+  #   end
+
+  #   class Person < ActiveRecord::Base
+  #     has_normalized_sti
+  #   end
+
+  #   class PersonType < ActiveRecord::Base
+  #   end
+
+  #   after calling has_normalized_sti:
+  #   * <tt>type</tt> - returns the name of the class of the type just as regular STI
+  #   * <tt>type=</tt> - set the type to something specific like regular STI
+  #   * <tt>normal_type</tt> - the Type object through the relation
+  module ClassMethods
+    # Configuration options are:
+    #
+    #   * type_class_name - belong_to this model for the type storage
+    #     (default: #{class_name}Type)
+    #   * foreign_key - specifies the column for id of the type (default: type_id)
+    #   * type_column - specifies the column name for the type string on the types table
+    #     (default: type_name)
+    def has_normalized_sti(options = {})
+      extend  HasNormalizedSti::SingletonMethods
+      include HasNormalizedSti::InstanceMethods
+
+      class_inheritable_accessor :sti_config
+      self.sti_config = {
+        :type_class_name => "#{table_name.classify}Type",
+        :foreign_key => 'type_id',
+        :type_column => 'type_name'
+      }
+      sti_config.update(options)
+      sti_config[:type_class_name] = sti_config[:type_class_name].to_s.classify
+
+      begin
+        sti_config[:type_class_name].constantize
+      rescue NameError
+        txt = "has_normalized_sti could not load #{sti_config[:type_class_name]}\n"
+        txt << "please make sure #{sti_config[:type_class_name]} is loaded before #{self.to_s}\n"
+        txt << "you might need to add require_dependency '#{sti_config[:type_class_name].underscore}'\n"
+        txt << "to #{self.to_s.underscore}.rb"
+        raise LoadError, txt
+      end
+
+      belongs_to :normal_type, :class_name => sti_config[:type_class_name], :foreign_key => sti_config[:foreign_key]
+      default_scope joins(:normal_type).select("#{table_name}.*, #{sti_config[:type_class_name].constantize.table_name}.#{sti_config[:type_column]}")
+      validates_associated :normal_type
+      validates_presence_of :normal_type
+    end
+  end
+
+  module SingletonMethods
+    def instantiate(record)
+      if record.has_key?(sti_config[:type_column])
+        type_name = record[sti_config[:type_column]]
+      else
+        associated_record = sti_config[:type_class_name].constantize.find_by_id(record[sti_config[:foreign_key].to_s])
+        type_name = associated_record.try(sti_config[:type_column])
+      end
+      model = find_sti_class(type_name).allocate
+      model.init_with('attributes' => record)
+      model
+    end
+
+    def find_sti_class(type_name)
+      if type_name.blank?
+        self
+      else
+        begin
+          if store_full_sti_class
+            ActiveSupport::Dependencies.constantize(type_name)
+          else
+            compute_type(type_name)
+          end
+        rescue NameError
+          raise SubclassNotFound,
+            "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " +
+            "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " +
+            "Please rename this column if you didn't intend it to be used for storing the inheritance class " +
+            "or overwrite #{name}.inheritance_column to use another column for that information."
+        end
+      end
+    end
+
+    def descends_from_active_record?
+      if superclass.abstract_class?
+        superclass.descends_from_active_record?
+      else
+        superclass == ActiveRecord::Base
+      end
+    end
+
+    def type_condition
+      sti_column = sti_config[:type_class_name].constantize.arel_table[sti_config[:type_column]]
+      condition = sti_column.eq(sti_name)
+      descendants.each { |subclass| condition = condition.or(sti_column.eq(subclass.sti_name)) }
+
+      condition
+    end
+  end
+
+  module InstanceMethods
+    def initialize(attributes = {})
+      super
+      self.type = self.class.to_s
+    end
+
+    def type
+      self.normal_type.try(sti_config[:type_column]) || self.class.to_s
+    end
+
+    def type=(type_name)
+      type_class = self.class.sti_config[:type_class_name].constantize
+      self.normal_type = type_class.send("find_or_initialize_by_#{sti_config[:type_column]}", type_name)
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, HasNormalizedSti

data/spec/has_normalized_sti_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe 'has_normalized_sti' do
+  describe 'classes' do
+    it 'should hook in to AR:Base' do
+      ActiveRecord::Base.should respond_to :has_normalized_sti
+    end
+  end
+
+  describe 'instances' do
+    before do
+      @person  = Person.new
+      @royal   = Royal.new
+      @peasant = Peasant.new
+    end
+
+    it 'should respond to type' do
+      @person.should respond_to(:type)
+    end
+
+    it 'should have type set to the (sub)class name' do
+      @person.type.should == 'Person'
+      @royal.type.should  == 'Royal'
+      @peasant.type.should == 'Peasant'
+    end
+
+    it 'should have an associated normal_type' do
+      @person.should respond_to(:normal_type)
+    end
+
+    it 'should have the normal_type be a new record if the type does not exist yet' do
+      @person.normal_type.should be_new_record
+    end
+
+    it 'should save the assocated normal_type if it was new' do
+      @person.save
+      @person.normal_type.should_not be_new_record
+    end
+
+    it 'should not allow a nil normal_type' do
+      @person.normal_type = nil
+      @person.save.should == false
+      @person.should have(1).errors_on(:normal_type)
+    end
+
+    it 'should set the normal_type to an existing record' do
+      PersonType.create(:type_name => 'Person')
+      Person.new.type_id.should_not be_nil
+      Person.new.normal_type.should_not be_new_record
+    end
+
+    it 'should return an object of the subclassed type when searched on the parent' do
+      @royal.save!
+      person = Person.find(@royal.id)
+      person.should be_a(Royal)
+    end
+
+    it 'should allow the type to be set manual and read back' do
+      @person.type = 'Royal'
+      @person.type.should == 'Royal'
+    end
+
+    it 'should allow a custom type class' do
+      @peasant.normal_type.should be_a(SpecialPersonType)
+    end
+
+    it 'should allow a custom foreign key' do
+      @peasant.save!
+      @peasant.type_id.should be_nil
+      @peasant.special_type_id.should_not be_nil
+    end
+
+    it 'should store the type in a custom column' do
+      @peasant.normal_type.type_name.should be_nil
+      @peasant.normal_type.special_person_type.should == 'Peasant'
+    end
+
+    it 'should be the right object when found from the base' do
+      @peasant.save!
+      SpecialPerson.find(@peasant.id).should be_a(Peasant)
+    end
+
+    it 'should work with the options as symbols' do
+      @farmer = Farmer.new
+      @farmer.normal_type.should be_a(SpecialPersonType)
+      @farmer.normal_type.type_name.should be_nil
+      @farmer.normal_type.special_person_type.should == 'Farmer'
+      @farmer.save!
+      @farmer.type_id.should be_nil
+      @farmer.special_type_id.should_not be_nil
+      ReallySpecialPerson.find(@farmer.id).should be_a(Farmer)
+    end
+
+    it 'should error if the type class is not loaded' do
+      lambda{
+        class ErrPerson < ActiveRecord::Base
+          has_normalized_sti :type_class_name => 'NonExistantType'
+        end
+      }.should raise_error(LoadError)
+    end
+
+    it 'should only return subclassed records' do
+      person = Person.create!
+      royal = Royal.create!
+
+      Royal.all.count.should == 1
+    end
+
+    it 'should only return subclassed and subsubclassed' do
+      person = Person.create!
+      royal = Royal.create!
+
+      class King < Royal
+      end
+
+      King.create!
+      Royal.all.count.should == 2
+    end
+
+  end
+end

data/spec/schema.rb

@@ -0,0 +1,12 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :people, :force => true do |t|
+    t.string  :full_name
+    t.integer :type_id
+    t.integer :special_type_id
+  end
+
+  create_table :person_types, :force => true do |t|
+    t.string :type_name
+    t.string :special_person_type
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'active_record'
+
+require 'rspec'
+require 'rspec/rails/extensions'
+require 'rspec/rails/matchers'
+require 'rspec/rails/adapters'
+require 'rspec/rails/fixture_support'
+
+RSpec.configure do |c|
+  c.use_transactional_examples = true
+end
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require File.dirname(__FILE__) + '/../init'
+
+ActiveRecord::Base.configurations={'test' => {:adapter => "sqlite3", :database => ":memory:"} }
+ActiveRecord::Base.establish_connection('test')
+load(File.dirname(__FILE__) + "/schema.rb")
+
+class PersonType < ActiveRecord::Base
+end
+
+class SpecialPersonType < ActiveRecord::Base
+  set_table_name :person_types
+end
+
+class Person < ActiveRecord::Base
+  has_normalized_sti
+end
+
+class SpecialPerson < ActiveRecord::Base
+  set_table_name :people
+  has_normalized_sti :type_class_name => 'SpecialPersonType', :type_column => 'special_person_type', :foreign_key => 'special_type_id'
+end
+
+class Royal < Person
+end
+
+class Peasant < SpecialPerson
+end
+
+class ReallySpecialPerson < ActiveRecord::Base
+  set_table_name :people
+  has_normalized_sti :type_class_name => :special_person_type, :type_column => :special_person_type, :foreign_key => :special_type_id
+end
+
+class Farmer < ReallySpecialPerson
+end

data/spec/speed_test.rb

@@ -0,0 +1,32 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+class TestPerson < ActiveRecord::Base
+  set_table_name "people"
+  set_inheritance_column :full_name
+end
+
+control_insert_start = Time.now
+10000.times do |i|
+  TestPerson.create!
+end
+control_insert_end = Time.now
+puts "Baseline insert #{control_insert_end - control_insert_start}"
+
+control_select_start = Time.now
+TestPerson.all
+control_select_end = Time.now
+puts "Baseline select #{control_select_end - control_select_start}"
+
+TestPerson.delete_all
+
+test_insert_start = Time.now
+10000.times do |i|
+  Person.create!
+end
+test_insert_end = Time.now
+puts "Test insert #{test_insert_end - test_insert_start}"
+
+test_select_start = Time.now
+Person.all
+test_select_end = Time.now
+puts "Test select #{test_select_end - test_select_start}"

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: has_normalized_sti
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Kevin Glowacz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+description: "      has_normalzied_sti expects the model to have a type_id column\n      referencing a types table containg all the possible types.\n      the types table will be auto populated with new types as new\n      subclasses are saved\n"
+email: kevin@glowacz.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- VERSION
+- has_normalized_sti.gemspec
+- init.rb
+- lib/has_normalized_sti.rb
+- spec/has_normalized_sti_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+- spec/speed_test.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3468596275297658209
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: allows rails STI to work when the type is normalized out
+test_files: []
+