dr_nic_magic_models 0.8.1 → 0.9.0

data/lib/base.rb

@@ -3,14 +3,10 @@
 module ActiveRecord
   class Base
     class << self
-
       public
-
         def get_unique_index_columns
             self.connection.indexes(self.table_name, "#{self.name} Indexes").select { |index| index.unique && index.columns.size == 1 }.map{ |index| index.columns.first }
-        end     
+        end
     end
-    
- 
   end
 end

data/lib/dr_nic_magic_models.rb

@@ -14,15 +14,18 @@ module DrNicMagicModels
     Logger = RAILS_DEFAULT_LOGGER rescue Logger.new(STDERR)
 end
 
+require 'dr_nic_magic_models/magic_model'
 require 'dr_nic_magic_models/schema'
 require 'dr_nic_magic_models/validations'
+require 'dr_nic_magic_models/inflector'
 require 'base'
+require 'module'
 require 'rails' rescue nil
 require 'connection_adapters/abstract_adapter'
 require 'connection_adapters/mysql_adapter'
 require 'connection_adapters/postgresql_adapter'
 
 # load the schema
-DrNicMagicModels::Schema.load_schema
+# TODO - add this to README - DrNicMagicModels::Schema.load_schema(true)
 
 

data/lib/dr_nic_magic_models/inflector.rb

@@ -0,0 +1,14 @@
+module DrNicMagicModels
+  class Inflector
+    def table_names   ; DrNicMagicModels::Schema.table_names; end
+    def tables        ; DrNicMagicModels::Schema.tables; end
+    def models        ; DrNicMagicModels::Schema.model; end
+    
+    def class_name(table_name)
+      ActiveRecord::Base.class_name(table_name)
+    end
+    
+    def post_class_creation(klass)
+    end
+  end
+end

data/lib/dr_nic_magic_models/magic_model.rb

@@ -0,0 +1,125 @@
+# Mixed into a class that is dynamically created, unless
+# the class was created by the Schema.load_schema process
+# which builds the whole class, thus no magicalness is 
+# needed
+module DrNicMagicModels::MagicModel
+  def self.append_features(base)
+    super
+    base.send(:include, InstanceMethods)
+    class << base
+      # 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
+  end
+  
+  module InstanceMethods
+    
+    def method_missing(method, *args, &block)
+      begin
+        super 
+      rescue
+        if unknown_method? method
+          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
+        add_known_unknown method
+        raise
+      end
+    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(method, *args, &block)
+      fkc = 
+        begin
+          self.class.connection.foreign_key_constraints(self.class.table_name, method) 
+        rescue NotImplementedError 
+          nil
+        end
+      if not fkc.nil? and fkc.length > 0
+        foreign_key = fkc.first.foreign_key
+        options = {:dependent => :destroy, :foreign_key => fkc.first.foreign_key, :class_name => self.class.class_name(fkc.first.reference_table)}
+      else
+        foreign_key = self.class.columns.select {|column| column.name == method.to_s.foreign_key}.first
+      end
+      options ||= {}
+      return add_belongs_to(method, options, *args, &block) if foreign_key
+    end
+
+    def add_belongs_to(method, options, *args, &block)
+      self.class.send 'belongs_to', method, options rescue puts $!
+      self.send(method, *args, &block)
+    end
+    
+    def find_has_some(method, *args, &block)
+      fkc = [method.to_s.pluralize, method.to_s.singularize].inject({}) do |pair, table_name|
+        fkc = begin
+                self.class.connection.foreign_key_constraints(table_name)
+              rescue NotImplementedError
+                nil
+              end
+        pair[table_name] = fkc if not fkc.blank?
+        pair
+      end
+      if not fkc.blank?
+        # assumes there is only one table found - that schema doesn't have a singular and plural table of same name
+        foreign_key = fkc.values.first.find {|fk| fk.reference_table == self.class.table_name}
+        if foreign_key
+          foreign_key = foreign_key.foreign_key
+          table_name = fkc.keys.first
+          klass = Module.const_get table_name.singularize.camelize rescue nil
+          options = {:foreign_key => foreign_key, :class_name => klass.name}
+        end
+      end
+      unless foreign_key
+        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
+      end
+      options ||= {}
+      return add_has_some(method, options, *args, &block) if foreign_key
+    end
+          
+    def add_has_some(method, options, *args, &block)
+      _method = method.to_s
+      association = _method.singularize == _method ? 'has_one' : 'has_many'
+      self.class.send association, method, options rescue puts $!
+      self.send(method, *args, &block)
+    end
+    
+    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_has_some_through(join_table, method, *args, &block)
+      puts "#{self.class}.has_many #{method.inspect}, #{join_table.inspect}, #{args.inspect}"
+      self.class.send 'has_many', method, :through => join_table.to_sym
+      self.send(method, *args, &block)
+    end
+  end
+end

data/lib/dr_nic_magic_models/schema.rb

@@ -1,227 +1,255 @@
 module DrNicMagicModels
-
+  
+  # ONE Schema per namespace module
+  # Person, Company, etc share the Object namespace module, ie. ::Person, ::Company
+  # Blog::Post, Blog::Comment, share the Blog namespace module
   class Schema
-    class << self
+    attr_reader :modul
     
-      # all in lower case please
-      ReservedTables = [:schema_info, :sessions]  
-      @@models = nil   
+    def initialize(modul)
+      @modul = modul
+      @table_name_prefix = modul.instance_variable_get("@table_name_prefix") rescue ''
+      logger.info "Create Schema for #{@modul}, table_name_prefix '#{@table_name_prefix}'"
+    end
     
-      def logger
-        @@logger ||= DrNicMagicModels::Logger
-      end
+    cattr_accessor :inflector
+    cattr_accessor :superklass
     
-      def models
-        load_schema if @@models.nil?
-        @@models
-      end
+    # Need to store models etc per-module, not in @ @models
+    def inflector
+      @inflector ||= Inflector.new
+    end
+    
+    # all in lower case please
+    ReservedTables = [:schema_info, :sessions]  
+    @models = nil   
+    
+    def logger
+      @logger ||= DrNicMagicModels::Logger
+    end
+    
+    def models
+      load_schema if @models.nil?
+      @models
+    end
+    
+    def tables
+      load_schema if @tables.nil?
+      @tables
+    end
+    
+    def table_names
+      load_schema if @table_names.nil?
+      @table_names
+    end
+    
+    def fks_on_table(table_name)
+      load_schema if @models.nil?
+      @fks_by_table[table_name.to_s] || []
+    end
+    
+    # active record only support 2 column link tables, otherwise use a model table, has_many and through
+    def is_link_table?(table_name)
+      load_schema if @models.nil?      
+      return @link_tables[table_name] if ! @link_tables[table_name].nil?
+      column_names = @conn.columns(table_name).map{|x| x.name }
+      @link_tables[table_name] = ! column_names.include?("id") && column_names.length == 2 && column_names.select { |x| x =~ /_id$/ } == column_names
+      return @link_tables[table_name]
+    end
+    
+    def link_tables_for_class(klass)
+      load_schema if @models.nil?      
+    end
+    
+    def load_schema(preload = false)
+      return if !@models.nil?
       
-      def fks_on_table(table_name)
-        load_schema if @@models.nil?
-        @@fks_by_table[table_name.to_s] || []
-      end
+      @superklass ||= ActiveRecord::Base
+      raise "No database connection" if !(@conn = @superklass.connection)
       
-      # active record only support 2 column link tables, otherwise use a model table, has_many and through
-      def is_link_table?(table_name)
-        load_schema if @@models.nil?      
-        return @@link_tables[table_name] if ! @@link_tables[table_name].nil?
-        column_names = @conn.columns(table_name).map{|x| x.name }
-        @@link_tables[table_name] = ! column_names.include?("id") && column_names.length == 2 && column_names.select { |x| x =~ /_id$/ } == column_names
-        return @@link_tables[table_name]
-      end
-     
-      def link_tables_for_class(klass)
-        load_schema if @@models.nil?      
-      end
-     
-      def load_schema
+      @models = ModelHash.new
+      @tables = Hash.new
+      @fks_by_table = Hash.new   
+      @link_tables = Hash.new
       
-        return if ! @@models.nil?
+      @table_names = @conn.tables
+      @table_names = @table_names.grep(/^#{@table_name_prefix}/) if @table_name_prefix
+      @table_names = @table_names.sort
       
-        raise "No database connection" if !(@conn = ActiveRecord::Base.connection)
-        
-        @@models = ModelHash.new
-        @@tables = Hash.new
-        @@fks_by_table = Hash.new   
-        @@link_tables = Hash.new
-
-        tables = @conn.tables.sort  
-                
-        # Work out which tables are in the model and which aren't
-        tables.each do |table_name|
-
-          # deal with reserved tables & link_tables && other stray id-less tables
-          next if ReservedTables.include?(table_name.downcase.to_sym) || is_link_table?(table_name) || ! @conn.columns(table_name).map{ |x| x.name}.include?("id")
-                   
-          # a model table then...
-          model_class_name = ActiveRecord::Base.class_name(table_name)
-          
-          logger.debug "Got a model table: #{table_name} => class #{model_class_name}"
-          
-          @@models[model_class_name] = table_name
-          @@tables[table_name] = model_class_name
-
-          # create by MAGIC!
-          begin
-            klass = model_class_name.constantize
-          rescue Exception => e
-            # create our class!
-            class_def = <<-end_eval
-              class #{model_class_name} < ActiveRecord::Base          
-                set_table_name('#{table_name}')
-              end
-            end_eval
-            eval(class_def, TOPLEVEL_BINDING)            
-            klass = model_class_name.constantize            
-          end
-
-          # magic up some validation          
-          klass.send(:extend, DrNicMagicModels::Validations)
-          klass.send(:generate_validations)
-          
-        end
-
-        # Process FKs?
-        if @conn.supports_fetch_foreign_keys?          
+      logger.info "For #{modul} tables are #{@table_names.inspect}"
+      
+      # Work out which tables are in the model and which aren't
+      @table_names.each do |table_name|
         
-          tables.each do |table_name| 
-            logger.debug "Getting FKs for #{table_name}"
-            @@fks_by_table[table_name] = Array.new                        
-            @conn.foreign_key_constraints(table_name).each do |fk| 
-              logger.debug "Got one: #{fk}"
-              @@fks_by_table[table_name].push(fk)              
-            end # do each fk
-  
-          end # each table
-        end         
-          
-        # Try to work out our link tables now...
-        @@models.keys.sort.each{|klass| process_table(@@models[klass.to_s])}
-        @@link_tables.keys.sort.each{|table_name| process_link_table(table_name) if @@link_tables[table_name]}        
-                
-
-      end
+        # deal with reserved tables & link_tables && other stray id-less tables
+        #key = 'id'
+        #case ActiveRecord::Base.primary_key_prefix_type
+        #  when :table_name
+        #    key = Inflector.foreign_key(table_name, false)
+        #  when :table_name_with_underscore
+        #    key = Inflector.foreign_key(table_name)
+        #end
+        #next if ReservedTables.include?(table_name.downcase.to_sym) || 
+        #        is_link_table?(table_name) || 
+        #        ! @conn.columns(table_name).map{ |x| x.name}.include?(key)
         
-      def process_table(table_name)
-      
-        logger.debug "Processing model table #{table_name}"
-      
-        # ok, so let's look at the foreign keys on the table...
-        belongs_to_klass = @@tables[table_name].constantize rescue return
-
-        processed_columns = Hash.new
-
-        fks_on_table(table_name).each do |fk|        
-          logger.debug "Found FK column by suffix _id [#{fk.foreign_key}]"            
-          has_some_klass = Inflector.classify(fk.reference_table).constantize rescue next
-          processed_columns[fk.foreign_key] = { :has_some_klass => has_some_klass }
-          processed_columns[fk.foreign_key].merge! add_has_some_belongs_to(belongs_to_klass, fk.foreign_key, has_some_klass) rescue next          
-        end    
+        table_name_clean = table_name.gsub(/^#{@table_name_prefix}/,'')
         
-        column_names = @conn.columns(table_name).map{ |x| x.name}
-        column_names.each do |column_name|        
-          next if not column_name =~ /_id$/
-          logger.debug "Found FK column by suffix _id [#{column_name}]"
-          if processed_columns.key?(column_name)
-            logger.debug "Skipping, already processed"
-            next
-          end
-          has_some_klass = Inflector.classify(column_name.sub(/_id$/,"")).constantize rescue next
-          processed_columns[column_name] = { :has_some_klass => has_some_klass }        
-          processed_columns[column_name].merge! add_has_some_belongs_to(belongs_to_klass, column_name, has_some_klass) rescue next
-        end
+        # a model table then...
+        model_class_name = inflector.class_name(table_name_clean)
         
-        #TODO: what if same classes in table?
+        logger.debug "Got a model table: #{table_name} => class #{model_class_name}"
         
-        # is this a link table with attributes? (has_many through?)
-        return if processed_columns.keys.length < 2
+        @models[model_class_name] = table_name
+        @tables[table_name] = model_class_name
         
-        processed_columns.keys.each do |key1|
-          processed_columns.keys.each do |key2|
-           next if key1 == key2
-           logger.debug "\n*** #{processed_columns[key1][:has_some_class]}.send 'has_many', #{processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym}, :through => #{processed_columns[key2][:has_some_name]}\n\n"
-           processed_columns[key1][:has_some_class].send 'has_many', processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym, :through => processed_columns[key2][:has_some_name].to_sym
-          end              
-        end
+        if preload
+          # create by MAGIC!
+          klass = model_class_name.constantize
+          
+          # Process FKs?
+          if @conn.supports_fetch_foreign_keys?          
             
+            tables.each do |table_name| 
+              logger.debug "Getting FKs for #{table_name}"
+              @fks_by_table[table_name] = Array.new                        
+              @conn.foreign_key_constraints(table_name).each do |fk| 
+                logger.debug "Got one: #{fk}"
+                @fks_by_table[table_name].push(fk)              
+              end # do each fk
+              
+            end # each table
+          end         
+          
+          # Try to work out our link tables now...
+          @models.keys.sort.each{|klass| process_table(@models[klass.to_s])}
+          @link_tables.keys.sort.each{|table_name| process_link_table(table_name) if @link_tables[table_name]}        
+        end  
       end
-
-        
-      def add_has_some_belongs_to(belongs_to_klass, belongs_to_fk, has_some_klass)
       
-          logger.debug "Trying to add a #{belongs_to_klass} belongs_to #{has_some_klass}..."
+    end
+    
+    def process_table(table_name)
       
-          # so this is a belongs_to & has_some style relationship...
-          # is it a has_many, or a has_one? Well, let's assume a has_one has a unique index on the column please... good db design, haha!      
-          unique = belongs_to_klass.get_unique_index_columns.include?(belongs_to_fk)
-          belongs_to_name = belongs_to_fk.sub(/_id$/, '').to_sym
-
-          logger.debug "\n*** #{belongs_to_klass}.send 'belongs_to', #{belongs_to_name}, :class_name => #{has_some_klass}, :foreign_key => #{belongs_to_fk}\n"
-          belongs_to_klass.send(:belongs_to, belongs_to_name, :class_name => has_some_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
-          
-          # work out if we need a prefix
-          has_some_name = ((unique ? belongs_to_klass.table_name.singularize : belongs_to_klass.table_name.pluralize) + (belongs_to_name.to_s == has_some_klass.table_name.singularize ? "" : "_as_"+belongs_to_name.to_s)).downcase.to_sym
-          method = unique ? :has_one : :has_many          
-          logger.debug "\n*** #{has_some_klass}.send(#{method}, #{has_some_name}, :class_name => #{belongs_to_klass.to_s}, :foreign_key => #{belongs_to_fk.to_sym})\n\n"
-          has_some_klass.send(method, has_some_name, :class_name => belongs_to_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
+      logger.debug "Processing model table #{table_name}"
+      
+      # ok, so let's look at the foreign keys on the table...
+      belongs_to_klass = @tables[table_name].constantize rescue return
+    
+      processed_columns = Hash.new
+      
+      fks_on_table(table_name).each do |fk|        
+        logger.debug "Found FK column by suffix _id [#{fk.foreign_key}]"            
+        has_some_klass = Inflector.classify(fk.reference_table).constantize rescue next
+      processed_columns[fk.foreign_key] = { :has_some_klass => has_some_klass }
+        processed_columns[fk.foreign_key].merge! add_has_some_belongs_to(belongs_to_klass, fk.foreign_key, has_some_klass) rescue next          
+      end    
+      
+      column_names = @conn.columns(table_name).map{ |x| x.name}
+      column_names.each do |column_name|        
+        next if not column_name =~ /_id$/
+        logger.debug "Found FK column by suffix _id [#{column_name}]"
+        if processed_columns.key?(column_name)
+          logger.debug "Skipping, already processed"
+          next
+        end
+        has_some_klass = Inflector.classify(column_name.sub(/_id$/,"")).constantize rescue next
+      processed_columns[column_name] = { :has_some_klass => has_some_klass }        
+        processed_columns[column_name].merge! add_has_some_belongs_to(belongs_to_klass, column_name, has_some_klass) rescue next
+      end
+      
+      #TODO: what if same classes in table?
+      
+      # is this a link table with attributes? (has_many through?)
+      return if processed_columns.keys.length < 2
+      
+      processed_columns.keys.each do |key1|
+        processed_columns.keys.each do |key2|
+          next if key1 == key2
+          logger.debug "\n*** #{processed_columns[key1][:has_some_class]}.send 'has_many', #{processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym}, :through => #{processed_columns[key2][:has_some_name]}\n\n"
+          processed_columns[key1][:has_some_class].send 'has_many', processed_columns[key2][:belongs_to_name].to_s.pluralize.to_sym, :through => processed_columns[key2][:has_some_name].to_sym
+        end              
+      end
+      
+    end
+    
+    def add_has_some_belongs_to(belongs_to_klass, belongs_to_fk, has_some_klass)
+      
+      logger.debug "Trying to add a #{belongs_to_klass} belongs_to #{has_some_klass}..."
+      
+      # so this is a belongs_to & has_some style relationship...
+      # is it a has_many, or a has_one? Well, let's assume a has_one has a unique index on the column please... good db design, haha!      
+      unique = belongs_to_klass.get_unique_index_columns.include?(belongs_to_fk)
+      belongs_to_name = belongs_to_fk.sub(/_id$/, '').to_sym
+      
+      logger.debug "\n*** #{belongs_to_klass}.send 'belongs_to', #{belongs_to_name}, :class_name => #{has_some_klass}, :foreign_key => #{belongs_to_fk}\n"
+      belongs_to_klass.send(:belongs_to, belongs_to_name, :class_name => has_some_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
+      
+      # work out if we need a prefix
+      has_some_name = (
+       (unique ? belongs_to_klass.table_name.singularize : belongs_to_klass.table_name) + 
+       (belongs_to_name.to_s == has_some_klass.table_name.singularize ? "" : "_as_"+belongs_to_name.to_s)
+      ).downcase.to_sym
+      method = unique ? :has_one : :has_many          
+      logger.debug "\n*** #{has_some_klass}.send(#{method}, #{has_some_name}, :class_name => #{belongs_to_klass.to_s}, :foreign_key => #{belongs_to_fk.to_sym})\n\n"
+      has_some_klass.send(method, has_some_name, :class_name => belongs_to_klass.to_s, :foreign_key => belongs_to_fk.to_sym)
+      
+      return { :method => method, :belongs_to_name => belongs_to_name, :has_some_name => has_some_name, :has_some_class => has_some_klass  }
       
-          return { :method => method, :belongs_to_name => belongs_to_name, :has_some_name => has_some_name, :has_some_class => has_some_klass  }
+    end
+    
+    def process_link_table(table_name)
+      
+      logger.debug "Processing link table #{table_name}"
       
+      classes_map = Hash.new
+      column_names = @conn.columns(table_name).map{ |x| x.name}
+      
+      # use foreign keys first
+      fks_on_table(table_name).each do |fk|
+        logger.debug "Processing fk: #{fk}"
+        klass = Inflector.classify(fk.reference_table).constantize rescue logger.debug("Cannot find model #{class_name} for table #{fk.reference_table}") && return
+        classes_map[fk.foreign_key] = klass              
       end
+      
+      logger.debug "Got #{classes_map.keys.length} references from FKs"
+      
+      if classes_map.keys.length < 2
         
-      def process_link_table(table_name)
-      
-        logger.debug "Processing link table #{table_name}"
-      
-        classes_map = Hash.new
-        column_names = @conn.columns(table_name).map{ |x| x.name}
-
-        # use foreign keys first
-        fks_on_table(table_name).each do |fk|
-          logger.debug "Processing fk: #{fk}"
-          klass = Inflector.classify(fk.reference_table).constantize rescue logger.debug("Cannot find model #{class_name} for table #{fk.reference_table}") && return
-          classes_map[fk.foreign_key] = klass              
-        end
-
-        logger.debug "Got #{classes_map.keys.length} references from FKs"
-
-        if classes_map.keys.length < 2
-          
-          #Fall back on good ol _id recognition
+        #Fall back on good ol _id recognition
         
-          column_names.each do |column_name|
+        column_names.each do |column_name|
           
-            # check we haven't processed by fks already
-            next if ! classes_map[column_name].nil? 
-            referenced_table = column_name.sub(/_id$/, '')
+          # check we haven't processed by fks already
+          next if ! classes_map[column_name].nil? 
+          referenced_table = column_name.sub(/_id$/, '')
           
-            begin            
-              klass = Inflector.classify(referenced_table).constantize                              
-              # fall back on FKs here
-              if ! klass.nil?               
-                classes_map[column_name] = klass               
-              end
-            rescue
-            end   
-          end
+          begin            
+            klass = Inflector.classify(referenced_table).constantize                              
+            # fall back on FKs here
+            if ! klass.nil?               
+              classes_map[column_name] = klass               
+            end
+          rescue
+          end   
         end
-          
-        # not detected the link table?
-        logger.debug "Got #{classes_map.keys.length} references"
-        logger.debug "Cannot detect both tables referenced in link table" && return if classes_map.keys.length != 2
-        
-        logger.debug "Adding habtm relationship"
-
-        logger.debug "\n*** #{classes_map[column_names[0]]}.send 'has_and_belongs_to_many', #{column_names[1].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[1]].to_s}, :join_table => #{table_name.to_sym}\n"
-        logger.debug "\n*** #{classes_map[column_names[1]]}.send 'has_and_belongs_to_many', #{column_names[0].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[0]].to_s}, :join_table => #{table_name.to_sym}\n\n"        
-        
-        classes_map[column_names[0]].send 'has_and_belongs_to_many', column_names[1].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[1]].to_s, :join_table => table_name.to_sym
-        classes_map[column_names[1]].send 'has_and_belongs_to_many', column_names[0].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[0]].to_s, :join_table => table_name.to_sym
-        
-      end   
-    end    
+      end
+      
+      # not detected the link table?
+      logger.debug "Got #{classes_map.keys.length} references"
+      logger.debug "Cannot detect both tables referenced in link table" && return if classes_map.keys.length != 2
+      
+      logger.debug "Adding habtm relationship"
+      
+      logger.debug "\n*** #{classes_map[column_names[0]]}.send 'has_and_belongs_to_many', #{column_names[1].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[1]].to_s}, :join_table => #{table_name.to_sym}\n"
+      logger.debug "\n*** #{classes_map[column_names[1]]}.send 'has_and_belongs_to_many', #{column_names[0].sub(/_id$/,'').pluralize.to_sym}, :class_name => #{classes_map[column_names[0]].to_s}, :join_table => #{table_name.to_sym}\n\n"        
+      
+      classes_map[column_names[0]].send 'has_and_belongs_to_many', column_names[1].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[1]].to_s, :join_table => table_name.to_sym
+      classes_map[column_names[1]].send 'has_and_belongs_to_many', column_names[0].sub(/_id$/,'').pluralize.to_sym, :class_name => classes_map[column_names[0]].to_s, :join_table => table_name.to_sym
+      
+    end   
   end
-    
+  
   class ModelHash < Hash
     def unenquire(class_id)
       @enquired ||= {}