dr_nic_magic_models 0.2.5 → 0.7.0

data/Rakefile

@@ -5,11 +5,11 @@ require 'rake/rdoctask'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
 require 'rake/contrib/rubyforgepublisher'
-require File.join(File.dirname(__FILE__), 'lib', 'dr_nic', 'magic_models', 'version')
+require File.join(File.dirname(__FILE__), 'lib', 'dr_nic_magic_models', 'version')
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'dr_nic_magic_models'
-PKG_VERSION   = DrNic::MagicModels::VERSION::STRING + PKG_BUILD
+PKG_VERSION   = DrNicMagicModels::VERSION::STRING + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -102,7 +102,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('activerecord', '= 1.14.3' + PKG_BUILD)
 
   s.require_path = 'lib'
-  s.autorequire = 'dr_nic'
+  s.autorequire = 'dr_nic_magic_models'
 
   s.has_rdoc = true
   s.extra_rdoc_files = %w( README )

data/install.rb

@@ -21,7 +21,7 @@ end
 # the acual gruntwork
 Dir.chdir("lib")
 
-Find.find("dr_nic", "dr_nic.rb") { |f|
+Find.find("dr_nic_magic_models", "dr_nic_magic_models.rb") { |f|
   if f[-3..-1] == ".rb"
     File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
   else

data/lib/base.rb

@@ -6,7 +6,7 @@ module ActiveRecord
       def new(*args)
         obj = old_new(*args)
         unless self.methods.include? 'generate_validations'
-          self.send(:include, DrNic::MagicModels::Validations)
+          self.send(:include, DrNicMagicModels::Validations)
           self.generate_validations
         end
         obj
@@ -15,26 +15,38 @@ module ActiveRecord
       def allocate
         obj = old_allocate
         unless self.methods.include? 'generate_validations'
-          self.send(:include, DrNic::MagicModels::Validations)
+          self.send(:include, DrNicMagicModels::Validations)
           self.generate_validations
         end
         obj
       end
+      
+      # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
+      #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      def reflect_on_association(association)
+        unless reflections[association]
+          # See if an assocation can be generated
+          self.new.send(association) rescue nil
+        end
+        reflections[association].is_a?(ActiveRecord::Reflection::AssociationReflection) ? reflections[association] : nil
+      end
     end
       
-    alias :normal_method_missing :method_missing
     class_eval do
+      alias :normal_method_missing :method_missing
       def method_missing(method, *args, &block)
         if unknown_method? method
-          result = find_has_some method, *args, &block
-          result = find_belongs_to method, *args, &block if not result
+          result = find_belongs_to method, *args, &block 
+          result = find_has_some method, *args, &block if not result
+          result = find_has_some_indirect method, *args, &block if not result
           return result if result
         end
-        known_unknown method
+        add_known_unknown method
         normal_method_missing(method, *args, &block)
       end
       
-      def known_unknown(method)
+      def add_known_unknown(method)
         @known_unknowns ||= {}
         @known_unknowns[method] = true
       end
@@ -43,6 +55,16 @@ module ActiveRecord
         @known_unknowns.nil? or @known_unknowns.include? method
       end
       
+      def find_belongs_to(method, *args, &block)
+        foreign_key = self.class.columns.select {|column| column.name == method.to_s.foreign_key}.first
+        return add_belongs_to(method, *args, &block) if foreign_key
+      end
+
+      def add_belongs_to(method, *args, &block)
+        self.class.send 'belongs_to', method
+        self.send(method, *args, &block)
+      end
+      
       def find_has_some(method, *args, &block)
         klass = Module.const_get method.to_s.downcase.singularize.camelize rescue nil
         foreign_key = klass.columns.select {|column| column.name == self.class.name.foreign_key}.first if klass
@@ -54,17 +76,26 @@ module ActiveRecord
         association = _method.singularize == _method ? 'has_one' : 'has_many'
         self.class.send association, method
         self.send(method, *args, &block)
-       end
+      end
       
-      def find_belongs_to(method, *args, &block)
-        foreign_key = self.class.columns.select {|column| column.name == method.to_s.foreign_key}.first
-        return add_belongs_to(method, *args, &block) if foreign_key
+      def find_has_some_indirect(method, *args, &block)
+        klass = Module.const_get method.to_s.downcase.singularize.camelize rescue return
+        join_table = nil
+        self.connection.tables.each do |table|
+          unless [self.class.table_name, klass.table_name].include? table
+            columns = self.connection.columns(table).map(&:name)
+            join_table = table if columns.include?(self.class.to_s.foreign_key) and columns.include?(klass.to_s.foreign_key) 
+          end
+          break if join_table
+        end
+        return add_has_some_through(join_table, method, *args, &block) if join_table
       end
-
-      def add_belongs_to(method, *args, &block)
-        self.class.send 'belongs_to', method
+      
+      def add_has_some_through(join_table, method, *args, &block)
+        self.class.send 'has_many', method, :through => join_table.to_sym
         self.send(method, *args, &block)
       end
+            
     end
   end
 end

data/lib/{dr_nic.rb → dr_nic_magic_models.rb}

@@ -11,7 +11,7 @@ unless defined?(ActiveRecord)
   end
 end
 
-require 'dr_nic/magic_models/schema'
-require 'dr_nic/magic_models/validations'
+require 'dr_nic_magic_models/schema'
+require 'dr_nic_magic_models/validations'
 require 'module'
 require 'base'

data/lib/dr_nic_magic_models/associations.rb

@@ -0,0 +1,12 @@
+module DrNicMagicModels
+  module Associations
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+    end
+    
+    # Composite key versions of Association functions
+    module ClassMethods
+    end
+  end
+end

data/lib/dr_nic_magic_models/schema.rb

@@ -0,0 +1,40 @@
+module DrNicMagicModels
+  class Schema
+    class << self
+      def models
+        @@models ||= nil
+        load_schema if @@models.blank?
+        @@models
+      end
+      
+      def reset
+        @@models = nil
+      end
+      
+      def load_schema
+        if conn = ActiveRecord::Base.connection
+          @@models = DrNicMagicModels::ModelHash.new
+          @@models.merge! conn.tables.inject({}) {|model_list,table_name| model_list[ActiveRecord::Base.class_name(table_name)] = table_name; model_list}
+        end
+      end
+    end
+  end
+    
+  class ModelHash < Hash
+    def unenquire(class_id)
+      @enquired ||= {}
+      @enquired[class_id = class_id.to_s] = false
+    end
+    
+    def enquired?(class_id)
+      @enquired ||= {}
+      @enquired[class_id.to_s]
+    end
+    
+    def [](class_id)
+      enquired?(class_id = class_id.to_s)
+      @enquired[class_id] = true
+      super(class_id)
+    end
+  end
+end

data/lib/dr_nic_magic_models/validations.rb

@@ -0,0 +1,26 @@
+module DrNicMagicModels
+  module Validations
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.generate_validations
+        
+      # Currently only invoked on generated classes
+      # How to include and invoke on all ARs? - hook into class loading??
+    end
+      
+    module ClassMethods
+      def generate_validations
+        unless @@generated_validations ||= false
+          @@generated_validations = true
+          column_names = self.columns.select {|column| !column.null and !column.primary}.map {|column| column.name.to_sym}
+          add_validation :validates_presence_of, column_names
+        end
+      end
+        
+      def add_validation(validation, column_names)
+        self.send validation, *column_names
+      end
+    end
+  end
+end

data/lib/dr_nic_magic_models/version.rb

@@ -0,0 +1,9 @@
+module DrNicMagicModels #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0 
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/module.rb

@@ -6,11 +6,13 @@ class Module
       return normal_const_missing(class_id)
     rescue
     end
-    unless table_name = DrNic::MagicModels::Schema.models[class_id]
-      raise NameError.new("uninitialized constant #{class_id}") if DrNic::MagicModels::Schema.models.enquired? class_id
+    unless table_name = DrNicMagicModels::Schema.models[class_id]
+      raise NameError.new("uninitialized constant #{class_id}") if DrNicMagicModels::Schema.models.enquired? class_id
     end
     klass_code = lambda {klass_code}
     klass = Class.new ActiveRecord::Base, &klass_code
     const_set class_id, klass
+    klass.set_table_name table_name
+    klass
   end
 end

data/lib/new_base.rb

@@ -0,0 +1,105 @@
+# Only needs to be an Include module for the generated classes, not for all ARs
+module ActiveRecord
+  class Base
+    class << self
+      alias old_new new
+      def new(*args)
+        obj = old_new(*args)
+        unless self.methods.include? 'generate_validations'
+          self.send(:include, DrNicMagicModels::Validations)
+          self.generate_validations
+        end
+        obj
+      end
+      alias old_allocate allocate
+      def allocate
+        obj = old_allocate
+        unless self.methods.include? 'generate_validations'
+          self.send(:include, DrNicMagicModels::Validations)
+          self.generate_validations
+        end
+        obj
+      end
+      
+      cattr_accessor :known_unknowns
+            
+      # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
+      #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+      #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
+      def reflect_on_association(association)
+        puts "Known association? #{association.to_sym.inspect} -> #{reflections[association]}"
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+      
+      def assess_unknown_method(instance, method, *args, &block)
+        result = find_belongs_to instance, method, *args, &block 
+        result = find_has_some instance, method, *args, &block if not result
+        result = find_has_some_indirect instance, method, *args, &block if not result
+        result
+      end
+      
+      def add_known_unknown(method)
+        known_unknowns ||= {}
+        known_unknowns[method] = true
+      end
+      
+      def unknown_method?(method)
+        known_unknowns.nil? or known_unknowns.include? method
+      end
+      
+      def find_belongs_to(instance, method, *args, &block)
+        foreign_key = self.columns.select {|column| column.name == method.to_s.foreign_key}.first
+        return add_belongs_to(instance, method, *args, &block) if foreign_key
+      end
+
+      def add_belongs_to(instance, method, *args, &block)
+        self.send 'belongs_to', method
+        instance.send(method, *args, &block)
+      end
+      
+      def find_has_some(instance, method, *args, &block)
+        klass = Module.const_get method.to_s.downcase.singularize.camelize rescue nil
+        foreign_key = klass.columns.select {|column| column.name == self.name.foreign_key}.first if klass
+        return add_has_some(instance, method, *args, &block) if foreign_key
+      end
+            
+      def add_has_some(instance, method, *args, &block)
+        _method = method.to_s
+        association = _method.singularize == _method ? 'has_one' : 'has_many'
+        self.send association, method
+        instance.send(instance, method, *args, &block)
+      end
+      
+      def find_has_some_indirect(instance, method, *args, &block)
+        klass = Module.const_get method.to_s.downcase.singularize.camelize rescue return
+        join_table = nil
+        self.connection.tables.each do |table|
+          unless [self.table_name, klass.table_name].include? table
+            columns = self.connection.columns(table).map(&:name)
+            join_table = table if columns.include?(self.to_s.foreign_key) and columns.include?(klass.to_s.foreign_key) 
+          end
+          break if join_table
+        end
+        return add_has_some_through(instance, join_table, method, *args, &block) if join_table
+      end
+      
+      def add_has_some_through(instance, join_table, method, *args, &block)
+        puts "self.class.send 'has_many', #{method}, :through => #{join_table.inspect}"
+        self.send 'has_many', method, :through => join_table.to_sym
+        instance.send(method, *args, &block)
+      end
+    end
+      
+    class_eval do
+      alias :normal_method_missing :method_missing
+      def method_missing(method, *args, &block)
+        if unknown_method? method
+          self.class.assess_unknown_method(self, method, *args, &block)
+        end
+        add_known_unknown method
+        normal_method_missing(method, *args, &block)
+      end
+      
+    end
+  end
+end

data/test/abstract_unit.rb

@@ -6,7 +6,7 @@ require 'active_record/fixtures'
 require 'active_support/binding_of_caller'
 require 'active_support/breakpoint'
 require 'connection'
-require 'dr_nic'
+require 'dr_nic_magic_models'
 
 QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
 

data/test/dummy_test.rb

@@ -1,7 +1,7 @@
 require 'abstract_unit'
-#require 'fixtures/users'
-#require 'fixtures/groups'
-#require 'fixtures/memberships'
+#require 'fixtures/user'
+#require 'fixtures/group'
+#require 'fixtures/membership'
 
 class DummyTest < Test::Unit::TestCase
   def setup

data/test/env_test.rb

@@ -3,9 +3,8 @@ require 'abstract_unit'
 class EnvTest < Test::Unit::TestCase
 
   def test_modules
-    assert_not_nil DrNic
-    assert_not_nil DrNic::MagicModels
-    assert_not_nil DrNic::MagicModels::Validations
-    assert_not_nil DrNic::MagicModels::Schema
+    assert_not_nil DrNicMagicModels
+    assert_not_nil DrNicMagicModels::Validations
+    assert_not_nil DrNicMagicModels::Schema
   end
 end

data/test/fixtures/db_definitions/mysql.sql

@@ -1,4 +1,4 @@
-CREATE TABLE `users` (
+CREATE TABLE `fun_users` (
   `id` int(11) NOT NULL auto_increment,
   `firstname` varchar(50) NOT NULL,
   `lastname` varchar(50) NOT NULL,
@@ -9,24 +9,22 @@ CREATE TABLE `users` (
 
 CREATE TABLE `groups` (
   `id` int(11) NOT NULL auto_increment,
-  `name` int(11) NOT NULL,
+  `name` varchar(50) NOT NULL,
   `description` varchar(50) default NULL,
   PRIMARY KEY  (`id`)
 ) TYPE=InnoDB;
 
-CREATE TABLE `memberships` (
+CREATE TABLE `group_memberships` (
   `id` int(11) NOT NULL auto_increment,
-  `user_id` int(11) NOT NULL,
+  `fun_user_id` int(11) NOT NULL,
   `group_id` int(11) NOT NULL,
   PRIMARY KEY  (`id`)
 ) TYPE=InnoDB;
 
-CREATE TABLE `person` (
+CREATE TABLE `group_tag` (
   `id` int(11) NOT NULL auto_increment,
-  `firstname` varchar(50) NOT NULL,
-  `lastname` varchar(50) NOT NULL,
-  `login` varchar(50) NOT NULL,
-  `email` varchar(50) NULL,
+  `name` varchar(50) NOT NULL,
+  `group_id` int(11) NOT NULL,
   PRIMARY KEY  (`id`)
 ) TYPE=InnoDB;
 

data/test/fixtures/fun_users.yml

@@ -0,0 +1,7 @@
+first:
+  id: 1
+  firstname: First
+  lastname: Person
+  login: first
+  email: first@person.com
+ 

data/test/fixtures/group_memberships.yml

@@ -0,0 +1,4 @@
+first_first:
+  id: 1
+  group_id: 1
+  fun_user_id: 1

data/test/fixtures/group_tag.yml

@@ -0,0 +1,9 @@
+first:
+  id: 1
+  name: Test
+  group_id: 1
+second:
+  id: 2
+  name: Also Test
+  group_id: 1
+ 

data/test/fixtures/groups.yml

@@ -0,0 +1,4 @@
+first:
+  id: 1
+  name: Group One
+  description: First group

data/test/invisible_model_access_test.rb

@@ -0,0 +1,37 @@
+require 'abstract_unit'
+
+class InvisibleModelAccessTest < Test::Unit::TestCase
+  fixtures :fun_users, :groups, :group_memberships, :group_tag
+  
+  def setup
+    @classes = [FunUser, Group, GroupMembership, GroupTag]
+    @group = groups(:first)
+  end
+  
+  def test_find
+    @classes.each do |klass|
+      assert_not_nil obj = klass.find(1)
+      assert_equal klass, obj.class
+    end
+  end
+  
+  def test_create
+    assert group = Group.create(:name => 'New Group')
+    assert_equal Group, group.class
+  end
+  
+  def test_update
+    assert @group.update_attributes(:name => 'Group 1')
+    assert_equal Group, @group.class
+  end
+  
+  def test_delete
+    assert @group.destroy
+  end
+  
+  def test_validations
+    group = Group.new
+    assert !group.valid?
+    assert_not_nil group.errors[:name]
+  end
+end

data/test/invisible_model_assoc_test.rb

@@ -0,0 +1,42 @@
+require 'abstract_unit'
+
+class InvisibleModelAssocTest < Test::Unit::TestCase
+  fixtures :fun_users, :groups, :group_memberships
+  
+  def setup
+    @group = groups(:first)
+    @user = fun_users(:first)
+    @membership = group_memberships(:first_first)
+  end
+  
+  def test_has_some
+    assert_equal @membership, @user.group_membership
+    assert_equal [@membership], @user.group_memberships
+    assert_equal @membership, @group.group_membership
+    assert_equal [@membership], @group.group_memberships
+  end
+  
+  def test_belongs_to
+    assert_equal @user, @membership.fun_user
+    assert_equal @group, @membership.group
+    GroupTag.find(:all, :conditions => ['group_id = ?', @group.id]).each do |group_tag|
+      assert_equal @group, group_tag.group
+    end
+  end
+  
+  def test_indirect
+    assert_equal [@user], @group.fun_users
+    assert_equal [@group], @user.groups 
+  end
+  
+  # TODO - Support these
+  #def test_more_indirect
+  #  group_tags = GroupTag.find(:all, :conditions => ['group_id = ?', @group.id])
+  #  assert_equal group_tags, @user.group_tags
+  #end
+  
+  #def test_more_indirect_via_belongs_to
+  #  @group_tag = group_tag(:first)
+  #  assert_equal [@user], @group_tag.fun_users
+  #end
+end

data/test/invisible_model_classes_test.rb

@@ -4,17 +4,16 @@ class InvisibleModelClassesTest < Test::Unit::TestCase
 
   def test_available
     assert_not_nil Group
-    assert_not_nil User
-    assert_not_nil Membership
-    assert_not_nil Person, "Could not find Person with singularized table name 'person'"
+    assert_not_nil FunUser
+    assert_not_nil GroupMembership
+    assert_not_nil GroupTag, "Could not find GroupTag with singularized table name 'GroupTag'"
   end
 
   def test_table_names
     assert_equal 'groups', Group.table_name
-    assert_equal 'users', User.table_name
-    assert_equal 'memberships', Membership.table_name
-    assert_equal 'person', Person.table_name
+    assert_equal 'fun_users', FunUser.table_name
+    assert_equal 'group_memberships', GroupMembership.table_name
+    assert_equal 'group_tag', GroupTag.table_name
   end
   
-  
 end

data/website/index.html

@@ -33,11 +33,246 @@
     <h1>Dr Nic&#8217;s Magic Models</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/magicmodels"; return false'>
       Get Version
-      <a href="http://rubyforge.org/projects/magicmodels" class="numbers">0.2.5</a>
+      <a href="http://rubyforge.org/projects/magicmodels" class="numbers">0.7.0</a>
     </div>
-    <h2>Instant look-see</h2>
+    <blockquote>
+<strong>conjure</strong>  1. To create events that appear to be magical<br />
+- <a href="http://www.dcopperfield.com/">David Copperfield</a> website
+</blockquote>
+If you&#8217;ve used Ruby on Rails you&#8217;ll have written at least one model class like this:
+
+	<p><pre class="syntax">
+<span class="keyword">class </span><span class="class">Person</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
+  <span class="ident">has_many</span> <span class="symbol">:memberships</span>
+  <span class="ident">has_many</span> <span class="symbol">:groups</span><span class="punct">,</span> <span class="symbol">:through</span> <span class="punct">=&gt;</span> <span class="symbol">:memberships</span>
+  <span class="ident">belongs_to</span> <span class="symbol">:family</span>
+  <span class="ident">validates_presence_of</span> <span class="symbol">:firstname</span><span class="punct">,</span> <span class="symbol">:lastname</span><span class="punct">,</span> <span class="symbol">:email</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>A few minutes later you&#8217;ll have wondered to yourself,</p>
+
+
+<blockquote>
+Why do I have write my own <code>has_many</code>, <code>belongs_to</code>, and <code>validates_presence_of</code> 
+commands if all the data is in the database schema?
+</blockquote>
+
+	<p>Now, for the very first time, your classes can look like this:</p>
+
+
+	<p><pre class="syntax">
+<span class="keyword">class </span><span class="class">Person</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>or, if you are lazy&#8230;</p>
+
+
+	<p><pre class="syntax">
+<span class="keyword">class </span><span class="class">Person</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span><span class="punct">;</span> <span class="keyword">end</span>
+</pre></p>
+
+
+	<p>or, if you read right to the end of this page, this&#8230;</p>
+
+
+	<p><pre class="syntax">
+
+</pre></p>
+
+
+	<p>Magic and mystery abound. All for you. Impress your friends, amaze your mother.</p>
+
+
+	<p><span class="caps">NOTE</span>: The gratuitous use of <strong>Dr Nic&#8217;s</strong> in the name should only enhance the mystical magicery,
+for magic needs a magician; and I love magic. I always wanted to create my own magic trick.
+So I shall be the magician for the sake of magic itself. I look a bit like Harry Potter
+if Harry were 31 and better dressed.</p>
+
+
+	<h2>Installation</h2>
+
+
+To install the Dr Nic&#8217;s Magic Models gem you can run the following command to 
+fetch the gem remotely from RubyForge:
+<pre>
+gem install dr_nic_magic_models
+</pre>
+
+	<p>or <a href="http://rubyforge.org/projects/magicmodels">download the gem manually</a> and 
+run the above command in the download directory.</p>
+
+
+	<p>Now you need to <code>require</code> the gem into your Ruby/Rails app. Insert the following
+line into your script (use <code>config/environment.rb</code> for your Rails apps):</p>
+
+
+<pre>
+require 'dr_nic_magic_models'
+</pre>
+
+	<p>Your application is now blessed with magical mystery.</p>
+
+
+	<h2>David Copperfield eat your Ruby-crusted heart out</h2>
+
+
+	<p>Let&#8217;s demonstrate the magical mystery in all its full-stage glory. Create a Ruby on Rails app:</p>
+
+
+	<p><pre class="syntax">
+<span class="ident">rails</span> <span class="ident">magic_show</span>
+<span class="ident">cd</span> <span class="ident">magic_show</span>
+<span class="ident">ruby</span> <span class="ident">script</span><span class="punct">/</span><span class="ident">generate</span> <span class="ident">model</span> <span class="constant">Person</span>
+<span class="ident">ruby</span> <span class="ident">script</span><span class="punct">/</span><span class="ident">generate</span> <span class="ident">model</span> <span class="constant">Group</span>
+<span class="ident">ruby</span> <span class="ident">script</span><span class="punct">/</span><span class="ident">generate</span> <span class="ident">model</span> <span class="constant">Membership</span>
+</pre></p>
+
+
+	<p>Update the migration <code>001_create_people.rb</code> with:
+<pre class="syntax">
+<span class="keyword">class </span><span class="class">CreatePeople</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Migration</span>
+  <span class="keyword">def </span><span class="method">self.up</span>
+    <span class="ident">create_table</span> <span class="symbol">:people</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">t</span><span class="punct">|</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:firstname</span><span class="punct">,</span> <span class="symbol">:string</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:lastname</span><span class="punct">,</span> <span class="symbol">:string</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:email</span><span class="punct">,</span> <span class="symbol">:string</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+    <span class="keyword">end</span>
+  <span class="keyword">end</span>
+
+  <span class="keyword">def </span><span class="method">self.down</span>
+    <span class="ident">drop_table</span> <span class="symbol">:people</span>
+  <span class="keyword">end</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>Similarly, update the <code>def self.up</code> method of <code>002_create_groups.rb</code>
+with:
+<pre class="syntax">
+    <span class="ident">create_table</span> <span class="symbol">:groups</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">t</span><span class="punct">|</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:name</span><span class="punct">,</span> <span class="symbol">:string</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:description</span><span class="punct">,</span> <span class="symbol">:datetime</span>
+    <span class="keyword">end</span>
+</pre></p>
+
+
+	<p>and <code>003_create_memberships.rb</code> with:
+<pre class="syntax">
+    <span class="ident">create_table</span> <span class="symbol">:memberships</span> <span class="keyword">do</span> <span class="punct">|</span><span class="ident">t</span><span class="punct">|</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:person_id</span><span class="punct">,</span> <span class="symbol">:integer</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+      <span class="ident">t</span><span class="punct">.</span><span class="ident">column</span> <span class="symbol">:group_id</span><span class="punct">,</span> <span class="symbol">:integer</span><span class="punct">,</span> <span class="symbol">:null</span> <span class="punct">=&gt;</span> <span class="constant">false</span>
+    <span class="keyword">end</span>
+</pre></p>
+
+
+Now create your database. For MySql:
+<pre>
+mysqladmin -u root create magic_show_development
+mysqladmin -u root create magic_show_test
+</pre>
+
+And run your migrations to create the three tables:
+<pre>
+rake migrate
+</pre>
+
+	<h2>And now for some <a href="http://en.wikipedia.org/wiki/List_of_conjuring_terms">woofle dust</a> ...</h2>
+
+
+	<p>At the end of <code>config/environment.rb</code> add the following line:</p>
+
+
+<pre>
+require 'dr_nic_magic_models'
+</pre>
+
+	<p>Now, let&#8217;s do a magic trick. First, let&#8217;s check our model classes (<code>app/models/person.rb</code> etc):</p>
+
+
+	<p><pre class="syntax">
+<span class="keyword">class </span><span class="class">Person</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
+<span class="keyword">end</span>
+<span class="keyword">class </span><span class="class">Group</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
+<span class="keyword">end</span>
+<span class="keyword">class </span><span class="class">Membership</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
+<span class="keyword">end</span>
+</pre></p>
+
+
+	<p>Nothing suspicious here. We have no validations and no associations. Just some plain old model classes.</p>
+
+
+	<p>For this trick, we&#8217;ll need an ordinary console session. Any old one lying around the house will do.</p>
+
+
+<pre>
+ruby script/console
+</pre>
+
+	<p>Now a normal model class is valid until you explicitly add <code>validates_xxx</code> commands.
+With Dr Nic&#8217;s Magic Models:</p>
+
+
+	<p><pre class="syntax">
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span> <span class="punct">=</span> <span class="constant">Person</span><span class="punct">.</span><span class="ident">new</span>
+<span class="punct">=&gt;</span> <span class="comment">#&lt;Person:0x393e0f8 @attributes={&quot;lastname&quot;=&gt;&quot;&quot;, &quot;firstname&quot;=&gt;&quot;&quot;, &quot;email&quot;=&gt;&quot;&quot;}, @new_record=true&gt;</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">valid?</span>
+<span class="punct">=&gt;</span> <span class="constant">false</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">errors</span>
+<span class="punct">=&gt;</span> <span class="punct">&lt;</span><span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Errors</span><span class="punct">:</span><span class="number">0x3938b18</span> <span class="attribute">@errors</span><span class="punct">={&quot;</span><span class="string">firstname</span><span class="punct">&quot;=&gt;[&quot;</span><span class="string">can't be blank</span><span class="punct">&quot;],</span> 
+<span class="punct">&quot;</span><span class="string">lastname</span><span class="punct">&quot;=&gt;[&quot;</span><span class="string">can't be blank</span><span class="punct">&quot;],</span> <span class="punct">&quot;</span><span class="string">email</span><span class="punct">&quot;=&gt;[&quot;</span><span class="string">can't be blank</span><span class="punct">&quot;]},</span> 
+<span class="attribute">@base</span><span class="punct">=&lt;</span><span class="constant">Person</span><span class="punct">:</span><span class="number">0x393e0f8</span> <span class="attribute">@errors</span><span class="punct">=&lt;</span><span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Errors</span><span class="punct">:</span><span class="number">0x3938b18</span> <span class="punct">...&gt;,</span> 
+<span class="attribute">@attributes</span><span class="punct">={&quot;</span><span class="string">lastname</span><span class="punct">&quot;=&gt;&quot;</span><span class="string"></span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">firstname</span><span class="punct">&quot;=&gt;&quot;</span><span class="string"></span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">email</span><span class="punct">&quot;=&gt;&quot;</span><span class="string"></span><span class="punct">&quot;},</span> <span class="attribute">@new_record</span><span class="punct">=</span><span class="constant">true</span><span class="punct">&gt;&gt;</span>
+</pre></p>
+
+
+	<p><strong>Kapoow!</strong> Instant validation!</p>
+
+
+	<p>Because you specified the three columns as <code>:null =&gt; false</code>,
+your ActiveRecord models will now automatically generated <code>validates_presence_of</code>
+for each non-null field.</p>
+
+
+	<p>Ok, we&#8217;re just warming up.</p>
+
+
+	<p>Your models normally require association commands (<code>has_many</code>, <code>belongs_to</code>, etc, as 
+demonstrated above) to have the brilliantly simple support that Rails/ActiveRecords are known for.</p>
+
+
+	<p>Let&#8217;s just watch what Dr Nic&#8217;s Magic Models can do without any effort at all&#8230;</p>
+
+
+	<p><pre class="syntax">
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span> <span class="punct">=</span> <span class="constant">Person</span><span class="punct">.</span><span class="ident">create</span><span class="punct">(</span><span class="symbol">:firstname</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">Nic</span><span class="punct">&quot;,</span> <span class="symbol">:lastname</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">Williams</span><span class="punct">&quot;,</span> <span class="symbol">:email</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">drnicwilliams@gmail.com</span><span class="punct">&quot;)</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">group</span> <span class="punct">=</span> <span class="constant">Group</span><span class="punct">.</span><span class="ident">create</span><span class="punct">(</span><span class="symbol">:name</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">Magic Models Forum</span><span class="punct">&quot;,</span> <span class="symbol">:description</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">http://groups.google.com/magicmodels</span><span class="punct">&quot;)</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">membership</span> <span class="punct">=</span> <span class="constant">Membership</span><span class="punct">.</span><span class="ident">create</span><span class="punct">(</span><span class="symbol">:person_id</span> <span class="punct">=&gt;</span> <span class="ident">person</span><span class="punct">,</span> <span class="symbol">:group_id</span> <span class="punct">=&gt;</span> <span class="ident">group</span><span class="punct">)</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">memberships</span><span class="punct">.</span><span class="ident">length</span>
+<span class="punct">=&gt;</span> <span class="number">1</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">membership</span><span class="punct">.</span><span class="ident">person</span>
+<span class="punct">=&gt;</span> <span class="punct">&lt;</span><span class="constant">Person</span><span class="punct">:</span><span class="number">0x38898e8</span> <span class="attribute">@attributes</span><span class="punct">={&quot;</span><span class="string">lastname</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">Williams</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">firstname</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">Nic</span><span class="punct">&quot;,</span> 
+<span class="punct">&quot;</span><span class="string">id</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">1</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">email</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">drnicwilliams@gmail.com</span><span class="punct">&quot;}&gt;</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">group</span><span class="punct">.</span><span class="ident">memberships</span>
+<span class="punct">=&gt;</span> <span class="punct">[&lt;</span><span class="constant">Membership</span><span class="punct">:</span><span class="number">0x3c8cd70</span> <span class="attribute">@attributes</span><span class="punct">={&quot;</span><span class="string">group_id</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">1</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">id</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">1</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">person_id</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">1</span><span class="punct">&quot;}&gt;]</span>
+</pre></p>
+
+
+	<p>The final association trick is a ripper. Automatic generation of <code>has_many :through</code> associations&#8230;</p>
+
+
+	<p><pre class="syntax">
+<span class="punct">&gt;&gt;</span> <span class="ident">person</span><span class="punct">.</span><span class="ident">groups</span>
+<span class="punct">=&gt;</span> <span class="punct">[&lt;</span><span class="constant">Group</span><span class="punct">:</span><span class="number">0x39047e0</span> <span class="attribute">@attributes</span><span class="punct">={&quot;</span><span class="string">name</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">Magic Models Forum</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">id</span><span class="punct">&quot;=&gt;&quot;</span><span class="string">1</span><span class="punct">&quot;,</span> <span class="punct">&quot;</span><span class="string">description</span><span class="punct">&quot;=&gt;</span><span class="constant">nil</span><span class="punct">}&gt;]</span>
+<span class="punct">&gt;&gt;</span> <span class="ident">group</span><span class="punct">.</span><span class="ident">people</span>
+<span class="punct">=&gt;</span> 
+</pre></p>
     <p class="coda">
-      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 28th July 2006<br>
+      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 7th August 2006<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -1,4 +1,204 @@
 h1. Dr Nic's Magic Models
 
-h2. Instant look-see
+<blockquote>
+*conjure*  1. To create events that appear to be magical<br />
+- "David Copperfield":http://www.dcopperfield.com/ website
+</blockquote>
+If you've used Ruby on Rails you'll have written at least one model class like this:
 
+<pre syntax='ruby'>
+class Person < ActiveRecord::Base
+  has_many :memberships
+  has_many :groups, :through => :memberships
+  belongs_to :family
+  validates_presence_of :firstname, :lastname, :email
+end
+</pre>
+
+A few minutes later you'll have wondered to yourself,
+
+<blockquote>
+Why do I have write my own <code>has_many</code>, <code>belongs_to</code>, and <code>validates_presence_of</code> 
+commands if all the data is in the database schema?
+</blockquote>
+
+Now, for the very first time, your classes can look like this:
+
+<pre syntax='ruby'>
+class Person < ActiveRecord::Base
+end
+</pre>
+
+or, if you are lazy...
+
+<pre syntax='ruby'>
+class Person < ActiveRecord::Base; end
+</pre>
+
+or, if you read right to the end of this page, this...
+
+<pre syntax='ruby'>
+
+</pre>
+
+Magic and mystery abound. All for you. Impress your friends, amaze your mother.
+
+NOTE: The gratuitous use of *Dr Nic's* in the name should only enhance the mystical magicery,
+for magic needs a magician; and I love magic. I always wanted to create my own magic trick.
+So I shall be the magician for the sake of magic itself. I look a bit like Harry Potter
+if Harry were 31 and better dressed.
+
+h2. Installation
+
+To install the Dr Nic's Magic Models gem you can run the following command to 
+fetch the gem remotely from RubyForge:
+<pre>
+gem install dr_nic_magic_models
+</pre>
+
+or "download the gem manually":http://rubyforge.org/projects/magicmodels and 
+run the above command in the download directory.
+
+Now you need to <code>require</code> the gem into your Ruby/Rails app. Insert the following
+line into your script (use <code>config/environment.rb</code> for your Rails apps):
+
+<pre>
+require 'dr_nic_magic_models'
+</pre>
+
+Your application is now blessed with magical mystery.
+
+h2. David Copperfield eat your Ruby-crusted heart out
+
+Let's demonstrate the magical mystery in all its full-stage glory. Create a Ruby on Rails app:
+
+<pre syntax="ruby">
+rails magic_show
+cd magic_show
+ruby script/generate model Person
+ruby script/generate model Group
+ruby script/generate model Membership
+</pre>
+
+Update the migration <code>001_create_people.rb</code> with:
+<pre syntax="ruby">
+class CreatePeople < ActiveRecord::Migration
+  def self.up
+    create_table :people do |t|
+      t.column :firstname, :string, :null => false
+      t.column :lastname, :string, :null => false
+      t.column :email, :string, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :people
+  end
+end
+</pre>
+
+Similarly, update the <code>def self.up</code> method of <code>002_create_groups.rb</code>
+with:
+<pre syntax="ruby">
+    create_table :groups do |t|
+      t.column :name, :string, :null => false
+      t.column :description, :datetime
+    end
+</pre>
+
+and <code>003_create_memberships.rb</code> with:
+<pre syntax="ruby">
+    create_table :memberships do |t|
+      t.column :person_id, :integer, :null => false
+      t.column :group_id, :integer, :null => false
+    end
+</pre>
+
+Now create your database. For MySql:
+<pre>
+mysqladmin -u root create magic_show_development
+mysqladmin -u root create magic_show_test
+</pre>
+
+And run your migrations to create the three tables:
+<pre>
+rake migrate
+</pre>
+
+h2. And now for some "woofle dust":http://en.wikipedia.org/wiki/List_of_conjuring_terms ...
+
+At the end of <code>config/environment.rb</code> add the following line:
+
+<pre>
+require 'dr_nic_magic_models'
+</pre>
+
+Now, let's do a magic trick. First, let's check our model classes (<code>app/models/person.rb</code> etc):
+
+<pre syntax="ruby">
+class Person < ActiveRecord::Base
+end
+class Group < ActiveRecord::Base
+end
+class Membership < ActiveRecord::Base
+end
+</pre>
+
+Nothing suspicious here. We have no validations and no associations. Just some plain old model classes.
+
+For this trick, we'll need an ordinary console session. Any old one lying around the house will do.
+
+<pre>
+ruby script/console
+</pre>
+
+Now a normal model class is valid until you explicitly add <code>validates_xxx</code> commands.
+With Dr Nic's Magic Models:
+
+<pre syntax="ruby">
+>> person = Person.new
+=> #<Person:0x393e0f8 @attributes={"lastname"=>"", "firstname"=>"", "email"=>""}, @new_record=true>
+>> person.valid?
+=> false
+>> person.errors
+=> <ActiveRecord::Errors:0x3938b18 @errors={"firstname"=>["can't be blank"], 
+"lastname"=>["can't be blank"], "email"=>["can't be blank"]}, 
+@base=<Person:0x393e0f8 @errors=<ActiveRecord::Errors:0x3938b18 ...>, 
+@attributes={"lastname"=>"", "firstname"=>"", "email"=>""}, @new_record=true>>
+</pre>
+
+*Kapoow!* Instant validation!
+
+Because you specified the three columns as <code>:null => false</code>,
+your ActiveRecord models will now automatically generated <code>validates_presence_of</code>
+for each non-null field.
+
+Ok, we're just warming up.
+
+Your models normally require association commands (<code>has_many</code>, <code>belongs_to</code>, etc, as 
+demonstrated above) to have the brilliantly simple support that Rails/ActiveRecords are known for.
+
+Let's just watch what Dr Nic's Magic Models can do without any effort at all...
+
+<pre syntax="ruby">
+>> person = Person.create(:firstname => "Nic", :lastname => "Williams", :email => "drnicwilliams@gmail.com")
+>> group = Group.create(:name => "Magic Models Forum", :description => "http://groups.google.com/magicmodels")
+>> membership = Membership.create(:person_id => person, :group_id => group)
+>> person.memberships.length
+=> 1
+>> membership.person
+=> <Person:0x38898e8 @attributes={"lastname"=>"Williams", "firstname"=>"Nic", 
+"id"=>"1", "email"=>"drnicwilliams@gmail.com"}>
+>> group.memberships
+=> [<Membership:0x3c8cd70 @attributes={"group_id"=>"1", "id"=>"1", "person_id"=>"1"}>]
+</pre>
+
+
+The final association trick is a ripper. Automatic generation of <code>has_many :through</code> associations...
+
+<pre syntax="ruby">
+>> person.groups
+=> [<Group:0x39047e0 @attributes={"name"=>"Magic Models Forum", "id"=>"1", "description"=>nil}>]
+>> group.people
+=> 
+</pre>

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: dr_nic_magic_models
 version: !ruby/object:Gem::Version 
-  version: 0.2.5
-date: 2006-07-28 00:00:00 +02:00
+  version: 0.7.0
+date: 2006-08-07 00:00:00 +02:00
 summary: Invisible validations, assocations and Active Record models themselves!
 require_paths: 
 - lib
@@ -12,7 +12,7 @@ email: drnicwilliams@gmail.com
 homepage: http://magicmodels.rubyforge.org
 rubyforge_project: magicmodels
 description: Associations and validations are automagically available to your ActiveRecord models. Model classes themselves are automagically generated if you haven't defined them already!
-autorequire: dr_nic
+autorequire: dr_nic_magic_models
 default_executable: 
 bindir: bin
 has_rdoc: true
@@ -32,27 +32,30 @@ files:
 - install.rb
 - README
 - CHANGELOG
-- lib/dr_nic
-- lib/dr_nic.rb
 - lib/module.rb
+- lib/dr_nic_magic_models
+- lib/dr_nic_magic_models.rb
+- lib/new_base.rb
 - lib/base.rb
-- lib/dr_nic/magic_models
-- lib/dr_nic/magic_models/validations.rb
-- lib/dr_nic/magic_models/schema.rb
-- lib/dr_nic/magic_models/version.rb
+- lib/dr_nic_magic_models/associations.rb
+- lib/dr_nic_magic_models/schema.rb
+- lib/dr_nic_magic_models/validations.rb
+- lib/dr_nic_magic_models/version.rb
 - test/connections
 - test/fixtures
 - test/abstract_unit.rb
 - test/dummy_test.rb
 - test/invisible_model_classes_test.rb
 - test/env_test.rb
+- test/invisible_model_access_test.rb
+- test/invisible_model_assoc_test.rb
 - test/connections/native_mysql
 - test/connections/native_mysql/connection.rb
 - test/fixtures/db_definitions
-- test/fixtures/reference_type.rb
-- test/fixtures/reference_types.yml
-- test/fixtures/reference_code.rb
-- test/fixtures/reference_codes.yml
+- test/fixtures/groups.yml
+- test/fixtures/group_tag.yml
+- test/fixtures/group_memberships.yml
+- test/fixtures/fun_users.yml
 - test/fixtures/db_definitions/mysql.sql
 - test/fixtures/db_definitions/mysql.drop.sql
 - website/index.txt

data/lib/dr_nic/magic_models/schema.rb

@@ -1,45 +0,0 @@
-module DrNic
-  module MagicModels
-    class Schema
-      class << self
-        def models
-          @@models ||= nil
-          load_schema if @@models.blank?
-          @@models
-        end
-        
-        def reset
-          @@models = nil
-        end
-        
-        def load_schema
-          if conn = ActiveRecord::Base.connection
-            @@models = DrNic::MagicModels::ModelHash.new
-            conn.tables.inspect
-            @@models.merge! conn.tables.inject({}) {|model_list,table_name| model_list[ActiveRecord::Base.class_name(table_name)] = table_name; model_list}
-          end
-        end
-      end
-    end
-    
-    class ModelHash < Hash
-      def unenquire(class_id)
-        @enquired ||= {}
-        @enquired[class_id = class_id.to_s] = false
-      end
-      
-      def enquired?(class_id)
-        @enquired ||= {}
-        result = @enquired[class_id.to_s]
-        #@enquired[class_id = class_id.to_s] = true
-        result
-      end
-      
-      def [](class_id)
-        enquired?(class_id = class_id.to_s)
-        @enquired[class_id] = true
-        super(class_id)
-      end
-    end
-  end
-end

data/lib/dr_nic/magic_models/validations.rb

@@ -1,28 +0,0 @@
-module DrNic
-  module MagicModels
-    module Validations
-      def self.append_features(base)
-        super
-        base.extend(ClassMethods)
-        base.generate_validations
-        
-        # Currently only invoked on generated classes
-        # How to include and invoke on all ARs? - hook into class loading??
-      end
-      
-      module ClassMethods
-        def generate_validations
-          unless @@generated_validations ||= false
-            @@generated_validations = true
-            column_names = self.columns.select {|column| !column.null and !column.primary}.map {|column| column.name.to_sym}
-            add_validation :validates_presence_of, column_names
-          end
-        end
-        
-        def add_validation(validation, column_names)
-          self.send validation, *column_names
-        end
-      end
-    end
-  end
-end

data/lib/dr_nic/magic_models/version.rb

@@ -1,11 +0,0 @@
-module DrNic #:nodoc:
-  module MagicModels #:nodoc:
-    module VERSION #:nodoc:
-      MAJOR = 0
-      MINOR = 2
-      TINY  = 5
-
-      STRING = [MAJOR, MINOR, TINY].join('.')
-    end
-  end
-end

data/test/fixtures/reference_code.rb

@@ -1,7 +0,0 @@
-class ReferenceCode < ActiveRecord::Base
-  set_primary_keys :reference_type_id, :reference_code
-  
-  belongs_to :reference_type, :foreign_key => "reference_type_id"
-  
-  validates_presence_of :reference_code, :code_label, :abbreviation
-end

data/test/fixtures/reference_codes.yml

@@ -1,28 +0,0 @@
-name_prefix_mr:
-  reference_type_id: 1
-  reference_code: 1
-  code_label: MR
-  abbreviation: Mr
-name_prefix_mrs:
-  reference_type_id: 1
-  reference_code: 2
-  code_label: MRS
-  abbreviation: Mrs
-name_prefix_ms:
-  reference_type_id: 1
-  reference_code: 3
-  code_label: MS
-  abbreviation: Ms
-  
-gender_male:
-  reference_type_id: 2
-  reference_code: 1
-  code_label: MALE
-  abbreviation: Male
-gender_female:
-  reference_type_id: 2
-  reference_code: 2
-  code_label: FEMALE
-  abbreviation: Female
-
-  

data/test/fixtures/reference_type.rb

@@ -1,7 +0,0 @@
-class ReferenceType < ActiveRecord::Base
-  set_primary_key :reference_type_id
-  has_many :reference_codes, :foreign_key => "reference_type_id"
-  
-  validates_presence_of :type_label, :abbreviation
-  validates_uniqueness_of :type_label
-end

data/test/fixtures/reference_types.yml

@@ -1,9 +0,0 @@
-name_prefix:
-  reference_type_id: 1
-  type_label: NAME_PREFIX
-  abbreviation: Name Prefix
-
-gender:
-  reference_type_id: 2
-  type_label: GENDER
-  abbreviation: Gender