merb_activerecord 0.4.3 → 0.5

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake/gempackagetask'
 
 PLUGIN = "merb_activerecord"
 NAME = "merb_activerecord"
-VERSION = "0.4.3"
+VERSION = "0.5"
 AUTHOR = "Duane Johnson"
 EMAIL = "canadaduane@gmail.com"
 HOMEPAGE = "http://merbivore.com"
@@ -20,7 +20,7 @@ spec = Gem::Specification.new do |s|
   s.author = AUTHOR
   s.email = EMAIL
   s.homepage = HOMEPAGE
-  s.add_dependency('merb', '>= 0.4.0')
+  s.add_dependency('merb', '>= 0.5')
   s.require_path = 'lib'
   s.autorequire = PLUGIN
   s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs,activerecord_generators}/**/*")
@@ -34,3 +34,7 @@ task :install do
   sh %{rake package}
   sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
 end
+
+task :release => :package do
+  sh %{rubyforge add_release merb #{PLUGIN} #{VERSION} pkg/#{NAME}-#{VERSION}.gem}
+end

data/lib/merb/orms/active_record/connection.rb

@@ -5,8 +5,8 @@ module Merb
   module Orms
     module ActiveRecord
       class << self
-        def config_file() MERB_ROOT / "config" / "database.yml" end
-        def sample_dest() MERB_ROOT / "config" / "database.sample.yml" end
+        def config_file() Merb.root / "config" / "database.yml" end
+        def sample_dest() Merb.root / "config" / "database.sample.yml" end
         def sample_source() File.dirname(__FILE__) / "database.sample.yml" end
       
         def copy_sample_config
@@ -19,7 +19,7 @@ module Merb
               # Convert string keys to symbols
               full_config = Erubis.load_yaml_file(config_file)
               config = (Merb::Plugins.config[:merb_active_record] = {})
-              (full_config[MERB_ENV.to_sym] || full_config[MERB_ENV]).each { |k, v| config[k.to_sym] = v }
+              (full_config[Merb.environment.to_sym] || full_config[Merb.environment]).each { |k, v| config[k.to_sym] = v }
                ::ActiveRecord::Base.configurations= full_config
               config
             end
@@ -33,11 +33,11 @@ module Merb
             Thread.new{ loop{ sleep(60*60); ::ActiveRecord::Base.verify_active_connections! } }.priority = -10
 
             ::ActiveRecord::Base.verification_timeout = 14400
-            ::ActiveRecord::Base.logger = MERB_LOGGER
+            ::ActiveRecord::Base.logger = Merb.logger
             ::ActiveRecord::Base.establish_connection config
           else
             copy_sample_config
-            puts "No database.yml file found in #{MERB_ROOT}/config."
+            puts "No database.yml file found in #{Merb.root}/config."
             puts "A sample file was created called database.sample.yml for you to copy and edit."
             exit(1)
           end
@@ -46,7 +46,7 @@ module Merb
         # Registering this ORM lets the user choose active_record as a session
         # in merb.yml's session_store: option.
         def register_session_type
-          Merb::Server.register_session_type("active_record",
+          Merb::BootLoader.register_session_type("activerecord",
             "merb/session/active_record_session",
             "Using ActiveRecord database sessions")
         end

data/lib/merb/orms/active_record/tasks/databases.rb

@@ -1,5 +1,5 @@
 task :environment do
- MERB_ENV = ( ENV['MERB_ENV'] || MERB_ENV ).to_sym
+ Merb.environment = ( ENV['Merb.environment'] || Merb.environment ).to_sym
 end
 
 namespace :db do
@@ -12,9 +12,9 @@ namespace :db do
     end
   end
 
-  desc 'Create the local database defined in config/database.yml for the current MERB_ENV'
+  desc 'Create the local database defined in config/database.yml for the current Merb.environment'
   task :create => :environment do
-    create_local_database(ActiveRecord::Base.configurations[MERB_ENV])
+    create_local_database(ActiveRecord::Base.configurations[Merb.environment])
   end
 
   def create_local_database(config)
@@ -53,13 +53,13 @@ namespace :db do
 
   desc 'Drops the database for the current environment'
   task :drop => :environment do
-    config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+    config = ActiveRecord::Base.configurations[Merb.environment || :development]
     p config
     case config[:adapter]
     when 'mysql'
       ActiveRecord::Base.connection.drop_database config[:database]
     when /^sqlite/
-      FileUtils.rm_f File.join(MERB_ROOT, config[:database])
+      FileUtils.rm_f File.join(Merb.root, config[:database])
     when 'postgresql'
       `dropdb "#{config[:database]}"`
     end
@@ -76,7 +76,7 @@ namespace :db do
 
   # desc "Retrieves the charset for the current environment's database"
   # task :charset => :environment do
-  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   config = ActiveRecord::Base.configurations[Merb.environment || :development]
   #   case config[:adapter]
   #   when 'mysql'
   #     ActiveRecord::Base.establish_connection(config)
@@ -88,7 +88,7 @@ namespace :db do
 
   # desc "Retrieves the collation for the current environment's database"
   # task :collation => :environment do
-  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   config = ActiveRecord::Base.configurations[Merb.environment || :development]
   #   case config[:adapter]
   #   when 'mysql'
   #     ActiveRecord::Base.establish_connection(config)
@@ -107,61 +107,61 @@ namespace :db do
     desc "Load fixtures into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
     task :load => :environment do
       require 'active_record/fixtures'
-      ActiveRecord::Base.establish_connection(MERB_ENV.to_sym)
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(MERB_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+      ActiveRecord::Base.establish_connection(Merb.environment.to_sym)
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(Merb.root, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
         Fixtures.create_fixtures('test/fixtures', File.basename(fixture_file, '.*'))
       end
     end
   end
 
   namespace :schema do
-    desc "Create a schema/schema.rb file that can be portably used against any DB supported by AR"
-    task :dump => :environment do
+    desc 'Create a schema/schema.rb file that can be portably used against any DB supported by AR'
+    task :dump do
       require 'active_record/schema_dumper'
       File.open(ENV['SCHEMA'] || "schema/schema.rb", "w") do |file|
         ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
       end
     end
-
+    
     desc "Load a schema.rb file into the database"
-    task :load => :environment do
+    task :load do
       file = ENV['SCHEMA'] || "schema/schema.rb"
       load(file)
     end
   end
 
-  namespace :structure do
+ namespace :structure do
     desc "Dump the database structure to a SQL file"
-    task :dump => :environment do
-      abcs = ActiveRecord::Base.configurations
-      case abcs[MERB_ENV][:adapter]
-      when "mysql", "oci", "oracle"
-        ActiveRecord::Base.establish_connection(abcs[MERB_ENV])
-        File.open("schema/#{MERB_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
-      when "postgresql"
-        ENV['PGHOST']     = abcs[MERB_ENV]["host"] if abcs[MERB_ENV]["host"]
-        ENV['PGPORT']     = abcs[MERB_ENV]["port"].to_s if abcs[MERB_ENV]["port"]
-        ENV['PGPASSWORD'] = abcs[MERB_ENV]["password"].to_s if abcs[MERB_ENV]["password"]
-        search_path = abcs[MERB_ENV]["schema_search_path"]
-        search_path = "--schema=#{search_path}" if search_path
-        `pg_dump -i -U "#{abcs[MERB_ENV]["username"]}" -s -x -O -f schema/#{MERB_ENV}_structure.sql #{search_path} #{abcs[MERB_ENV]["database"]}`
-        raise "Error dumping database" if $?.exitstatus == 1
-      when "sqlite", "sqlite3"
-        dbfile = abcs[MERB_ENV]["database"] || abcs[MERB_ENV]["dbfile"]
-        `#{abcs[MERB_ENV]["adapter"]} #{dbfile} .schema > schema/#{MERB_ENV}_structure.sql`
-      when "sqlserver"
-        `scptxfr /s #{abcs[MERB_ENV]["host"]} /d #{abcs[MERB_ENV]["database"]} /I /f db\\#{MERB_ENV}_structure.sql /q /A /r`
-        `scptxfr /s #{abcs[MERB_ENV]["host"]} /d #{abcs[MERB_ENV]["database"]} /I /F db\ /q /A /r`
-      when "firebird"
-        set_firebird_env(abcs[MERB_ENV])
-        db_string = firebird_db_string(abcs[MERB_ENV])
-        sh "isql -a #{db_string} > schema/#{MERB_ENV}_structure.sql"
-      else
-        raise "Task not supported by '#{abcs[MERB_ENV][:adapter]}'"
+    task :dump do
+      config = ActiveRecord::Base.configurations[Merb.environment.to_sym]
+      case config[:adapter]
+        when "mysql", "oci", "oracle"
+          ActiveRecord::Base.establish_connection(config[Merb.environment])
+          File.open("schema/#{Merb.environment}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+        when "postgresql"
+          ENV['PGHOST']     = config[:host] if config[:host]
+          ENV['PGPORT']     = config[:port].to_s if config[:port]
+          ENV['PGPASSWORD'] = config[:password].to_s if config[:password]
+          search_path = config[:schema_search_path]
+          search_path = "--schema=#{search_path}" if search_path
+          `pg_dump -i -U "#{config[:username]}" -s -x -O -f schema/#{Merb.environment}_structure.sql #{search_path} #{config[:database]}`
+          raise "Error dumping database" if $?.exitstatus == 1
+        when "sqlite", "sqlite3"
+          dbfile = config[:database] || config[:dbfile]
+          `#{config[:adapter]} #{dbfile} .schema > schema/#{Merb.environment}_structure.sql`
+        when "sqlserver"
+          `scptxfr /s #{config[:host]} /d #{config[:database]} /I /f schema\\#{Merb.environment}_structure.sql /q /A /r`
+          `scptxfr /s #{config[:host]} /d #{config[:database]} /I /F schema\ /q /A /r`
+        when "firebird"
+          set_firebird_env(config[Merb.environment])
+          db_string = firebird_db_string(config[Merb.environment])
+          sh "isql -a #{db_string} > schema/#{Merb.environment}_structure.sql"
+        else
+          raise "Task not supported by '#{config[:adapter]}'"
       end
 
       if ActiveRecord::Base.connection.supports_migrations?
-        File.open("schema/#{MERB_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+        File.open("schema/#{Merb.environment}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
       end
     end
   end
@@ -169,84 +169,78 @@ namespace :db do
   namespace :test do
     desc "Recreate the test database from the current environment's database schema"
     task :clone => %w(db:schema:dump db:test:purge) do
-      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+      ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations[:test])
       ActiveRecord::Schema.verbose = false
       Rake::Task["db:schema:load"].invoke
     end
 
-
     desc "Recreate the test databases from the development structure"
     task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
-      abcs = ActiveRecord::Base.configurations
-      case abcs["test"]["adapter"]
-      when "mysql"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
-        IO.readlines("schema/#{MERB_ENV}_structure.sql").join.split("\n\n").each do |table|
-          ActiveRecord::Base.connection.execute(table)
-        end
-      when "postgresql"
-        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
-        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
-        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
-        `psql -U "#{abcs["test"]["username"]}" -f schema/#{MERB_ENV}_structure.sql #{abcs["test"]["database"]}`
-      when "sqlite", "sqlite3"
-        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
-        `#{abcs["test"]["adapter"]} #{dbfile} < schema/#{MERB_ENV}_structure.sql`
-      when "sqlserver"
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{MERB_ENV}_structure.sql`
-      when "oci", "oracle"
-        ActiveRecord::Base.establish_connection(:test)
-        IO.readlines("schema/#{MERB_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
-        end
-      when "firebird"
-        set_firebird_env(abcs["test"])
-        db_string = firebird_db_string(abcs["test"])
-        sh "isql -i schema/#{MERB_ENV}_structure.sql #{db_string}"
-      else
-        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+      config = ActiveRecord::Base.configurations[:test]
+      case config[:adapter]
+        when "mysql"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+          IO.readlines("schema/#{Merb.environment}_structure.sql").join.split("\n\n").each do |table|
+            ActiveRecord::Base.connection.execute(table)
+          end
+        when "postgresql"
+          ENV['PGHOST']     = config[:host] if config[:host]
+          ENV['PGPORT']     = config[:port].to_s if config[:port]
+          ENV['PGPASSWORD'] = config[:password].to_s if config[:password]
+          `psql -U "#{config[:username]}" -f schema/#{Merb.environment}_structure.sql #{config[:database]}`
+        when "sqlite", "sqlite3"
+          dbfile = config[:database] ||config[:dbfile]
+          `#{config[:adapter]} #{dbfile} < schema/#{Merb.environment}_structure.sql`
+        when "sqlserver"
+          `osql -E -S #{config[:host]} -d #{config[:database]} -i schema\\#{Merb.environment}_structure.sql`
+        when "oci", "oracle"
+          ActiveRecord::Base.establish_connection(:test)
+          IO.readlines("schema/#{Merb.environment}_structure.sql").join.split(";\n\n").each do |ddl|
+            ActiveRecord::Base.connection.execute(ddl)
+          end
+        when "firebird"
+          set_firebird_env(config)
+          db_string = firebird_db_string(config)
+          sh "isql -i schema/#{Merb.environment}_structure.sql #{db_string}"
+        else
+          raise "Task not supported by '#{config[:adapter]}'"
       end
     end
-
+    
     desc "Empty the test database"
-    task :purge => :environment do
-      abcs = ActiveRecord::Base.configurations
-      case abcs["test"]["adapter"]
-      when "mysql"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"])
-      when "postgresql"
-        ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
-        ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
-        ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
-        enc_option = "-E #{abcs["test"]["encoding"]}" if abcs["test"]["encoding"]
-
-        ActiveRecord::Base.clear_active_connections!
-        `dropdb -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
-        `createdb #{enc_option} -U "#{abcs["test"]["username"]}" #{abcs["test"]["database"]}`
-      when "sqlite","sqlite3"
-        dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
-        File.delete(dbfile) if File.exist?(dbfile)
-      when "sqlserver"
-        dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
-        `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{MERB_ENV}_structure.sql`
-      when "oci", "oracle"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
-          ActiveRecord::Base.connection.execute(ddl)
-        end
-      when "firebird"
-        ActiveRecord::Base.establish_connection(:test)
-        ActiveRecord::Base.connection.recreate_database!
-      else
-        raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+    task :purge do
+      config = ActiveRecord::Base.configurations[:test]
+      case config[:adapter]
+        when "mysql"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.recreate_database(config[:database])
+        when "postgresql"
+          ENV['PGHOST']     = config[:host] if config[:host]
+          ENV['PGPORT']     = configs[:port].to_s if config[:port]
+          ENV['PGPASSWORD'] = configs[:password].to_s if config[:password]
+          enc_option = "-E #{config[:encoding]}" if config[:encoding]
+          ActiveRecord::Base.clear_active_connections!
+          `dropdb -U "#{config[:username]}" #{config[:database]}`
+          `createdb #{enc_option} -U "#{config[:username]}" #{config[:database]}`
+        when "sqlite","sqlite3"
+          dbfile = config[:database] || config[:dbfile]
+          File.delete(dbfile) if File.exist?(dbfile)
+        when "sqlserver"
+        config  ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+            ActiveRecord::Base.connection.execute(ddl)
+          end
+        when "firebird"
+          ActiveRecord::Base.establish_connection(:test)
+          ActiveRecord::Base.connection.recreate_database!
+        else
+          raise "Task not supported by '#{config[:adapter]}'"
       end
     end
 
-    desc 'Prepare the test database and load the schema'
-    task :prepare => :environment do
+    desc "Prepare the test database and load the schema"
+    task :prepare => ["db:test:clone_structure", "db:test:clone"] do
       if defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
         Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:clone" }[ActiveRecord::Base.schema_format]].invoke
       end

data/lib/merb/session/active_record_session.rb

@@ -1,9 +1,9 @@
-require 'active_record'
+require "active_record"
 
 module Merb
   module SessionMixin
     def setup_session
-      MERB_LOGGER.info("Setting up session")
+      Merb.logger.info("Setting up session")
       before = cookies[_session_id_key]
       request.session, cookies[_session_id_key] = Merb::ActiveRecordSession.persist(cookies[_session_id_key])
       @_fingerprint = Marshal.dump(request.session.data).hash
@@ -11,7 +11,7 @@ module Merb
     end
 
     def finalize_session
-      MERB_LOGGER.info("Finalize session")
+      Merb.logger.info("Finalize session")
       request.session.save if @_fingerprint != Marshal.dump(request.session.data).hash
       set_cookie(_session_id_key, request.session.session_id, _session_expiry) if (@_new_cookie || request.session.needs_new_cookie)
     end
@@ -84,14 +84,22 @@ module Merb
     end 
   
     # Lazy-delete of session data 
-    def delete
-      self.data = {}
+    def delete(key = nil)
+      key ? self.data.delete(key) : self.data.clear
     end
   
     def [](key)
       data[key]
     end
   
+    def empty?
+      data.empty?
+    end
+  
+    def each(&b)
+      data.each(&b)
+    end
+  
     def []=(key, val)
       data[key] = val
     end

data/lib/merb_activerecord.rb

@@ -1,6 +1,6 @@
 # make sure we're running inside Merb
 if defined?(Merb::Plugins)
-  if Merb::Server.app_loaded?
+  if Merb::BootLoader.app_loaded?
     puts "Warning: The merb_active_record gem must be loaded before the application"
   else
     require "merb/orms/active_record/connection"

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
+rubygems_version: 0.9.0
 specification_version: 1
 name: merb_activerecord
 version: !ruby/object:Gem::Version 
-  version: 0.4.3
-date: 2007-11-12 00:00:00 -06:00
+  version: "0.5"
+date: 2008-01-09 00:00:00 -08:00
 summary: Merb plugin that provides ActiveRecord support for Merb
 require_paths: 
 - lib
@@ -92,5 +92,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.4.0
+        version: "0.5"
     version: