voraz-dr_nic_magic_models 0.9.2

data/CHANGELOG

@@ -0,0 +1,9 @@
+* 0.2.5 * - Initial public release
+- ActiveRecords can now be auto-created in memory when first referenced
+  from their table name, without an explicit class definition.
+- ActiveRecords will automatically include validates_presence_of on
+  each field with :null => false
+- ActiveRecords will automatically generate simple has_many, has_one,
+  belongs_to assocations based upon assumed foreign keys. E.g.
+  foreign key to products table is assumed to be product_id.
+

data/History.txt

@@ -0,0 +1,33 @@
+== TRUNK 2007-06-30
+
+* Allows ActiveRecord::StatementInvalid for attempts to find pluralised tables that don't exist
+* Refactored Rakefile into namespaces by database
+
+== 0.9.2 / 2007-4-30
+
+* 3 major bugfixes:
+    * #generate_validations now works if you haven't already created a connection to the database; previously
+			validations wouldn't get created until you had already established the connection; now it does it for 
+			you if its not already established
+		* Associations can be generated via the assignment methods, e.g. @membership.group= will generate the "belongs_to :group" association now. This allows the website tutorial to work correctly! Yay. That is, you can now do: Membership.create(:person => person, :group => group)
+		* has_many's should work now
+
+== 0.9.1 / 2007-4-11
+
+* 1 minor enhancement:
+    * ActiveRecord::Base includes all the magic model functionality via the MagicModel module
+    * Existing ARs can get magic validation via #generate_validations call
+    * Website tutorial works :D
+			
+== 0.9.0 / 2007-4-9
+
+* 1 major enhancement:
+        * Support for dynamic loading of classes again
+* 2 new DB supported:
+        * Tests run on sqlite (no fk support)
+        * Tests run on postgresql (fk support)
+            * Including FK bug fix
+* Many fixes that I've lost track of
+* History.txt to keep track of changes like these
+* Using Hoe for Rakefile
+* Use modules to specify common table prefixes

data/Manifest.txt

@@ -0,0 +1,56 @@
+CHANGELOG
+History.txt
+Manifest.txt
+README
+Rakefile
+install.rb
+lib/base.rb
+lib/connection_adapters/abstract/schema_statements.rb
+lib/connection_adapters/abstract_adapter.rb
+lib/connection_adapters/mysql_adapter.rb
+lib/connection_adapters/postgresql_adapter.rb
+lib/dr_nic_magic_models.rb
+lib/dr_nic_magic_models/inflector.rb
+lib/dr_nic_magic_models/magic_model.rb
+lib/dr_nic_magic_models/schema.rb
+lib/dr_nic_magic_models/validations.rb
+lib/dr_nic_magic_models/version.rb
+lib/module.rb
+lib/rails.rb
+scripts/txt2html
+scripts/txt2js
+test.db
+test/abstract_unit.rb
+test/connections/native_mysql/connection.rb
+test/connections/native_postgresql/connection.rb
+test/connections/native_sqlite/connection.rb
+test/dummy_test.rb
+test/env_test.rb
+test/fixtures/.DS_Store
+test/fixtures/adjectives.yml
+test/fixtures/adjectives_fun_users.yml
+test/fixtures/db_definitions/mysql.drop.sql
+test/fixtures/db_definitions/mysql.sql
+test/fixtures/db_definitions/postgresql.sql
+test/fixtures/db_definitions/sqlite.sql
+test/fixtures/fun_users.yml
+test/fixtures/group_memberships.yml
+test/fixtures/group_tag.yml
+test/fixtures/groups.yml
+test/foreign_keys_test.rb
+test/fun_user_plus.rb
+test/invisible_model_access_test.rb
+test/invisible_model_assoc_test.rb
+test/invisible_model_classes_test.rb
+test/magic_module_test.rb
+test/test_existing_model.rb
+website/index.html
+website/index.txt
+website/javascripts/rounded_corners_lite.inc.js
+website/stylesheets/screen.css
+website/template.js
+website/template.rhtml
+website/version-raw.js
+website/version-raw.txt
+website/version.js
+website/version.txt

data/Rakefile

@@ -0,0 +1,149 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'hoe'
+require File.join(File.dirname(__FILE__), 'lib', 'dr_nic_magic_models', 'version')
+
+AUTHOR = "nicwilliams"  # can also be an array of Authors
+EMAIL = "drnicwilliams@gmail.com"
+DESCRIPTION = "Dr Nic's Magic Models - Invisible validations, assocations and Active Record models themselves!"
+GEM_NAME = "dr_nic_magic_models" # what ppl will type to install your gem
+RUBYFORGE_PROJECT = "magicmodels" # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+
+
+NAME = "magic_multi_connections"
+REV = nil # UNCOMMENT IF REQUIRED: File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
+VERS = ENV['VERSION'] || (DrNicMagicModels::VERSION::STRING + (REV ? ".#{REV}" : ""))
+CLEAN.include ['**/.*.sw?', '*.gem', '.config']
+RDOC_OPTS = ['--quiet', '--title', "dr_nic_magic_models documentation",
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs = CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  
+  #p.extra_deps     - An array of rubygem dependencies.
+  #p.spec_extras    - A hash of extra values to set in the gemspec.
+end
+
+# Run the unit tests
+ADAPTERS = %w( sqlite mysql postgresql ) # UNTESTED - postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase )
+for adapter in ADAPTERS
+  Rake::TestTask.new("test_#{adapter}") { |t|
+    t.libs << "test" << "test/connections/native_#{adapter}"
+    t.pattern = "test/*_test{,_#{adapter}}.rb"
+    t.verbose = true
+  }
+end
+
+task :default do
+  puts "To run tests, call the explicit test_<adapter> task"
+end
+
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+namespace :mysql do
+  desc 'Build the MySQL test databases'
+  task :build_databases do 
+    puts File.join(SCHEMA_PATH, 'mysql.sql')
+    user   = 'root'
+    sh %{ mysqladmin -u #{user} -p create "#{GEM_NAME}_unittest" }
+    sh %{ mysql -u #{user} -p "#{GEM_NAME}_unittest" < #{File.join(SCHEMA_PATH, 'mysql.sql')} }
+  end
+
+  desc 'Drop the MySQL test databases'
+  task :drop_databases do 
+    user   = 'root'
+    sh %{ mysqladmin -u #{user} -p -f drop "#{GEM_NAME}_unittest" }
+  end
+
+  desc 'Rebuild the MySQL test databases'
+
+  task :rebuild_databases => [:drop_databases, :build_databases]
+  
+  task :test => :test_mysql
+end
+
+namespace :sqlite do
+  desc 'Build the sqlite test databases'
+  task :build_databases do 
+    file = File.join(SCHEMA_PATH, 'sqlite.sql')
+    cmd = "sqlite3 test.db < #{file}"
+    puts cmd
+    sh %{ #{cmd} }
+  end
+
+  desc 'Drop the sqlite test databases'
+  task :drop_databases do 
+    sh %{ rm -f test.db }
+  end
+
+  desc 'Rebuild the sqlite test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+  
+  task :test => :test_sqlite
+end
+
+namespace :postgresql do
+  desc 'Build the PostgreSQL test databases'
+  task :build_databases do 
+    sh %{ createdb "#{GEM_NAME}_unittest" }
+    sh %{ psql "#{GEM_NAME}_unittest" -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} }
+  end
+
+  desc 'Drop the PostgreSQL test databases'
+  task :drop_databases do 
+    sh %{ dropdb "#{GEM_NAME}_unittest" }
+  end
+
+  desc 'Rebuild the PostgreSQL test databases'
+  task :rebuild_databases => [:drop_databases, :build_databases]
+  
+  task :test => :test_postgresql
+end
+
+
+desc 'Generate website files'
+task :website_generate do
+  sh %{ ruby scripts/txt2html website/index.txt > website/index.html }
+  sh %{ ruby scripts/txt2js website/version.txt > website/version.js }
+  sh %{ ruby scripts/txt2js website/version-raw.txt > website/version-raw.js }
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
+  host = "#{config["username"]}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+  local_dir = 'website'
+  sh %{rsync -av --delete #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload]

data/install.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+# this was adapted from rdoc's install.rb by ways of Log4r
+
+$sitedir = CONFIG["sitelibdir"]
+unless $sitedir
+  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/ }
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# the acual gruntwork
+Dir.chdir("lib")
+
+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
+    File::makedirs(File.join($sitedir, *f.split(/\//)))
+  end
+}

data/lib/base.rb

@@ -0,0 +1,12 @@
+#TODO: Use :dependent for FK cascade?
+
+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

data/lib/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,32 @@
+
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+
+    # Generic holder for foreign key constraint meta-data from the database schema.
+    class ForeignKeyConstraint < Struct.new(:name, :table, :foreign_key, :reference_table, :reference_column, :on_update, :on_delete)
+    end
+    
+    class AbstractAdapter
+
+      # Does this adapter support the ability to fetch foreign key information?  
+      # Backend specific, as the abstract adapter always returns +false+.
+      def supports_fetch_foreign_keys?
+        false
+      end
+      
+      def foreign_key_constraints(table, name = nil)
+        raise NotImplementedError, "foreign_key_constraints is not implemented for #{self.class}"
+      end
+      
+      def remove_foreign_key_constraint(table_name, constraint_name)
+        raise NotImplementedError, "rename_table is not implemented for #{self.class}"
+      end      
+
+      protected
+        def symbolize_foreign_key_constraint_action(constraint_action)
+          return nil if constraint_action.nil?
+          constraint_action.downcase.gsub(/\s/, '_').to_sym
+        end
+    end
+  end
+end

data/lib/connection_adapters/mysql_adapter.rb

@@ -0,0 +1,42 @@
+# Foreign Key support from http://wiki.rubyonrails.org/rails/pages/Foreign+Key+Schema+Dumper+Plugin
+
+module ActiveRecord
+  module ConnectionAdapters
+    class MysqlAdapter < AbstractAdapter
+      def supports_fetch_foreign_keys?
+        true
+      end
+      
+      def foreign_key_constraints(table, name = nil)
+        constraints = [] 
+        execute("SHOW CREATE TABLE #{table}", name).each do |row|
+          row[1].each do |create_line|
+            if create_line.strip =~ /CONSTRAINT `([^`]+)` FOREIGN KEY \(`([^`]+)`\) REFERENCES `([^`]+)` \(`([^`]+)`\)([^,]*)/          
+              constraint = ForeignKeyConstraint.new(Regexp.last_match(1), table, Regexp.last_match(2), Regexp.last_match(3), Regexp.last_match(4), nil, nil)
+            
+              constraint_params = {}
+              
+              unless Regexp.last_match(5).nil?
+                Regexp.last_match(5).strip.split('ON ').each do |param|
+                  constraint_params[Regexp.last_match(1).upcase] = Regexp.last_match(2).strip.upcase if param.strip =~ /([^ ]+) (.+)/
+                end
+              end
+            
+              constraint.on_update = symbolize_foreign_key_constraint_action(constraint_params['UPDATE']) if constraint_params.include? 'UPDATE'
+              constraint.on_delete = symbolize_foreign_key_constraint_action(constraint_params['DELETE']) if constraint_params.include? 'DELETE'
+
+              constraints << constraint
+            end
+          end
+        end
+    
+        constraints
+      end
+      
+      def remove_foreign_key_constraint(table_name, constraint_name)
+        execute "ALTER TABLE #{table_name} DROP FOREIGN KEY #{constraint_name}"
+      end      
+
+    end
+  end
+end

data/lib/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,45 @@
+# Foreign Key support from http://wiki.rubyonrails.org/rails/pages/Foreign+Key+Schema+Dumper+Plugin
+
+module ActiveRecord
+  module ConnectionAdapters
+    class PostgreSQLAdapter < AbstractAdapter
+
+      def supports_fetch_foreign_keys?
+        true
+      end
+
+      def foreign_key_constraints(table, name = nil)
+        
+        
+        sql =  "SELECT conname, pg_catalog.pg_get_constraintdef(oid) AS consrc FROM pg_catalog.pg_constraint WHERE contype='f' "
+        sql += "AND conrelid = (SELECT oid FROM pg_catalog.pg_class WHERE relname='#{table}')"
+        
+        result = query(sql, name)
+        
+        keys = []
+        re = /(?i)^FOREIGN KEY \((.+)\) REFERENCES (.+)\((.+)\)(?: ON UPDATE (\w+))?(?: ON DELETE (\w+))?$/
+        result.each do |row| 
+          # pg_catalog.pg_get_constraintdef returns a string like this:
+          # FOREIGN KEY (user_id) REFERENCES users(id) ON UPDATE CASCADE ON DELETE CASCADE          
+          if match = re.match(row[1])
+            
+            keys << ForeignKeyConstraint.new(row[0],
+                                             table,
+                                             match[1],
+                                             match[2],
+                                             match[3],
+                                             symbolize_foreign_key_constraint_action(match[4]),
+                                             symbolize_foreign_key_constraint_action(match[5]))
+          end
+        end
+        
+        keys
+      end
+      
+      def remove_foreign_key_constraint(table_name, constraint_name)
+        execute "ALTER TABLE #{table_name} DROP CONSTRAINT #{constraint_name}"
+      end
+      
+    end
+  end
+end

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,135 @@
+# 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)
+      method_clean = clean_method method
+      fkc = 
+        begin
+          self.class.connection.foreign_key_constraints(self.class.table_name, method_clean) 
+        rescue NotImplementedError 
+          nil
+        end
+      if !fkc.nil? && 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_clean.to_s.foreign_key}.first
+      end
+      options ||= {}
+      return add_belongs_to(method, method_clean, options, *args, &block) if foreign_key
+    end
+
+    def add_belongs_to(method, method_clean, options, *args, &block)
+      self.class.send 'belongs_to', method_clean.to_sym, options rescue puts $!
+      self.send(method, *args, &block)
+    end
+    
+    def find_has_some(method, *args, &block)
+      method_clean = clean_method method
+      fkc = [method_clean.to_s.pluralize, method_clean.to_s.singularize].inject({}) do |pair, table_name|
+        fkc = begin
+                self.class.connection.foreign_key_constraints(table_name)
+              rescue NotImplementedError
+                nil
+              rescue  ActiveRecord::StatementInvalid
+                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_clean.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, method_clean, options, *args, &block) if foreign_key
+    end
+          
+    def add_has_some(method, method_clean, options, *args, &block)
+      association = method_clean.singularize == method_clean ? 'has_one' : 'has_many'
+      self.class.send association, method_clean.to_sym, 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)
+      self.class.send 'has_many', method, :through => join_table.to_sym
+      self.send(method, *args, &block)
+    end
+    
+  private
+    
+    def clean_method(method)
+      method.to_s.gsub(/=$/,'') # remove any = from the end of the method name
+    end
+  end
+end