merb_activerecord 0.4.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 YOUR NAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,7 @@
+merb_active_record
+=================
+
+A plugin for the Merb framework that provides active record access
+
+After you install the plugin, you have access to the ar_migration generator in your merb projects
+example: /merb/root/script/generate ar_migration new_migration

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+
+PLUGIN = "merb_activerecord"
+NAME = "merb_activerecord"
+VERSION = "0.4.2"
+AUTHOR = "Duane Johnson"
+EMAIL = "canadaduane@gmail.com"
+HOMEPAGE = "http://merbivore.com"
+SUMMARY = "Merb plugin that provides ActiveRecord support for Merb"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb', '>= 0.4.0')
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs,activerecord_generators}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/merb_active_record.rb
+Add your Merb rake tasks to lib/merb_active_record/merbtasks.rb

data/activerecord_generators/database_sessions_migration/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/activerecord_generators/database_sessions_migration/database_sessions_migration_generator.rb

@@ -0,0 +1,51 @@
+require 'merb'
+class DatabaseSessionsMigrationGenerator < RubiGen::Base
+  
+  default_options :author => nil
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @name = 'database_sessions'
+  end
+
+  def manifest
+    record do |m|
+    # Ensure appropriate folder(s) exists
+    m.directory 'schema/migrations'
+
+    # Create stubs
+    highest_migration = Dir[Dir.pwd+'/schema/migrations/*'].map{|f| File.basename(f) =~ /^(\d+)/; $1}.max
+    filename = format("%03d_%s", (highest_migration.to_i+1), @name.snake_case)
+    m.template "sessions_migration.erb", "schema/migrations/#{filename}.rb"
+    puts banner
+
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+A migration to add sessions to your database has been created.
+Run 'rake db:migrate' to add the sessions migration to your database.
+
+EOS
+    end
+
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+    
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+end

data/activerecord_generators/database_sessions_migration/templates/sessions_migration.erb

@@ -0,0 +1,15 @@
+class DatabaseSessions < ActiveRecord::Migration
+  def self.up
+		create_table :sessions do |t|
+		  t.column :session_id, :text
+		  t.column :data,       :text
+		end
+  end
+
+  def self.down
+		drop_table :sessions
+  end
+end
+
+
+

data/activerecord_generators/migration/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/activerecord_generators/migration/migration_generator.rb

@@ -0,0 +1,14 @@
+require 'merb/generators/merb_generator_helpers'
+
+class MigrationGenerator < Merb::GeneratorHelpers::MigrationGeneratorBase
+  
+  def initialize( *args )
+    super( *args )
+    @migration_template_name = "new_migration.erb"
+  end
+  
+  def self.superclass
+    RubiGen::Base
+  end
+    
+end

data/activerecord_generators/migration/templates/new_migration.erb

@@ -0,0 +1,15 @@
+class <%= class_name.snake_case.camel_case %> < ActiveRecord::Migration
+  def self.up
+    <%= "create_table :#{table_name} do |t|" if table_name %>
+<% for attribute in table_attributes -%>
+      t.column :<%= attribute.name %>, :<%= attribute.type %> 
+<% end -%>
+    <%= "end" if table_name %>    
+  end
+
+  def self.down
+<% if table_name -%>
+    drop_table :<%= table_name %>
+<% end -%>
+  end
+end

data/activerecord_generators/model/USAGE

@@ -0,0 +1,4 @@
+Description:
+  
+  
+Usage:

data/activerecord_generators/model/model_generator.rb

@@ -0,0 +1,16 @@
+require 'merb/generators/merb_generator_helpers'
+
+class ModelGenerator < Merb::GeneratorHelpers::ModelGeneratorBase
+  
+  def initialize( *args )
+    super( *args )
+    @model_template_name = "new_model.erb"
+    @migration_generator_name = "migration"
+    @model_test_generator_name = "merb_model_test"
+  end
+  
+  def self.superclass
+    RubiGen::Base
+  end
+    
+end

data/activerecord_generators/model/templates/new_model.erb

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

data/activerecord_generators/resource_controller/resource_controller_generator.rb

@@ -0,0 +1,26 @@
+require 'merb/generators/merb_generator_helpers'
+
+class ResourceControllerGenerator < Merb::GeneratorHelpers::ControllerGeneratorBase
+
+  def initialize(*args)
+    runtime_options = args.last.is_a?(Hash) ? args.pop : {}
+    name, *actions = args.flatten
+    runtime_options[:actions] = %w[index show new edit]
+    runtime_options[:test_stub_generator] = "merb_controller_test"
+    super( [name], runtime_options )
+  end
+
+  def self.superclass
+    RubiGen::Base
+  end
+  
+  protected
+  def banner
+        <<-EOS
+  Creates a Merb controller, views and specs using Active Record Models
+
+  USAGE: #{$0} #{spec.name} resource_name"
+  EOS
+  end
+  
+end

data/activerecord_generators/resource_controller/templates/controller.rb

@@ -0,0 +1,54 @@
+<% klass = class_name.singularize -%>
+<% ivar = class_name.snake_case.singularize -%>
+class <%= class_name %> < Application
+  provides :xml, :js, :yaml
+  
+  def index
+    @<%= ivar %>s = <%= klass %>.find(:all)
+    render @<%= ivar %>s
+  end
+  
+  def show
+    @<%= ivar %> = <%= klass %>.find(params[:id])
+    render @<%= ivar %>
+  end
+  
+  def new
+    only_provides :html
+    @<%= ivar %> = <%= klass %>.new(params[:<%= ivar %>])
+    render
+  end
+  
+  def create
+    @<%= ivar %> = <%= klass %>.new(params[:<%= ivar %>])
+    if @<%= ivar %>.save
+      redirect url(:<%= ivar %>, @<%= ivar %>)
+    else
+      render :action => :new
+    end
+  end
+  
+  def edit
+    only_provides :html
+    @<%= ivar %> = <%= klass %>.find(params[:id])
+    render
+  end
+  
+  def update
+    @<%= ivar %> = <%= klass %>.find(params[:id])
+    if @<%= ivar %>.update_attributes(params[:<%= ivar %>])
+      redirect url(:<%= ivar %>, @<%= ivar %>)
+    else
+      raise BadRequest
+    end
+  end
+  
+  def destroy
+    @<%= ivar %> = <%= klass %>.find(params[:id])
+    if @<%= ivar %>.destroy
+      redirect url(:<%= ivar %>s)
+    else
+      raise BadRequest
+    end
+  end
+end

data/activerecord_generators/resource_controller/templates/edit.html.erb

@@ -0,0 +1 @@
+Edit for <%= class_name %>

data/activerecord_generators/resource_controller/templates/helper.rb

@@ -0,0 +1,5 @@
+module Merb
+module <%= class_name %>Helper
+  
+  end
+end

data/activerecord_generators/resource_controller/templates/index.html.erb

@@ -0,0 +1 @@
+Index for <%= class_name %>

data/activerecord_generators/resource_controller/templates/new.html.erb

@@ -0,0 +1 @@
+New for <%= class_name %>

data/activerecord_generators/resource_controller/templates/show.html.erb

@@ -0,0 +1 @@
+Show for <%= class_name %>

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

@@ -0,0 +1,56 @@
+require 'fileutils'
+require 'active_record'
+
+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 sample_source() File.dirname(__FILE__) / "database.sample.yml" end
+      
+        def copy_sample_config
+          FileUtils.cp sample_source, sample_dest unless File.exists?(sample_dest)
+        end
+      
+        def config
+          @config ||=
+            begin
+              # 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 }
+               ::ActiveRecord::Base.configurations= full_config
+              config
+            end
+        end
+
+        # Database connects as soon as the gem is loaded
+        def connect
+          if File.exists?(config_file)
+            puts "Connecting to database..."
+
+            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.establish_connection config
+          else
+            copy_sample_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
+        end
+        
+        # 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/session/active_record_session",
+            "Using ActiveRecord database sessions")
+        end
+      end
+    end
+  end
+end

data/lib/merb/orms/active_record/database.sample.yml

@@ -0,0 +1,17 @@
+---
+# This is a sample database file for the ActiveRecord ORM
+:development: &defaults
+  :adapter: mysql
+  :database: sample_development
+  :username: the_user
+  :password: secrets
+  :host: localhost
+  :socket: /tmp/mysql.sock
+
+:test:
+  <<: *defaults
+  :database: sample_test
+
+:production:
+  <<: *defaults
+  :database: sample_production

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

@@ -0,0 +1,285 @@
+task :environment do
+ MERB_ENV = ( ENV['MERB_ENV'] || MERB_ENV ).to_sym
+end
+
+namespace :db do
+  namespace :create do
+    desc 'Create all the local databases defined in config/database.yml'
+    task :all => :environment do
+      ActiveRecord::Base.configurations.each_value do |config|
+        create_local_database(config)
+      end
+    end
+  end
+
+  desc 'Create the local database defined in config/database.yml for the current MERB_ENV'
+  task :create => :environment do
+    create_local_database(ActiveRecord::Base.configurations[MERB_ENV])
+  end
+
+  def create_local_database(config)
+    # Only connect to local databases
+    if config[:host] == 'localhost' || config[:host].blank?
+      begin
+        ActiveRecord::Base.establish_connection(config)
+        ActiveRecord::Base.connection
+      rescue
+        case config[:adapter]
+        when 'mysql'
+          #~ @charset   = ENV['CHARSET']   || 'utf8'
+          #~ @collation = ENV['COLLATION'] || 'utf8_general_ci'
+          begin
+            ActiveRecord::Base.establish_connection(config.merge({:database => nil}))
+            ActiveRecord::Base.connection.create_database(config[:database]) #, {:charset => @charset, :collation => @collation})
+            ActiveRecord::Base.establish_connection(config)
+            p "MySQL #{config[:database]} database succesfully created"
+          rescue
+            $stderr.puts "Couldn't create database for #{config.inspect}"
+          end
+        when 'postgresql'
+          `createdb "#{config[:database]}" -E utf8`
+        when 'sqlite'
+          `sqlite "#{config[:database]}"`
+        when 'sqlite3'
+          `sqlite3 "#{config[:database]}"`
+        end
+      else
+        p "#{config[:database]} already exists"
+      end
+    else
+      p "This task only creates local databases. #{config[:database]} is on a remote host."
+    end
+  end
+
+  desc 'Drops the database for the current environment'
+  task :drop => :environment do
+    config = ActiveRecord::Base.configurations[MERB_ENV || :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])
+    when 'postgresql'
+      `dropdb "#{config[:database]}"`
+    end
+  end
+
+  desc "Migrate the database through scripts in schema/migrations. Target specific version with VERSION=x"
+  task :migrate => :environment do
+    ActiveRecord::Migrator.migrate("schema/migrations/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke if ActiveRecord::Base.schema_format == :ruby
+  end
+
+  desc 'Drops, creates and then migrates the database for the current environment. Target specific version with VERSION=x'
+  task :reset => ['db:drop', 'db:create', 'db:migrate']
+
+  # desc "Retrieves the charset for the current environment's database"
+  # task :charset => :environment do
+  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   case config[:adapter]
+  #   when 'mysql'
+  #     ActiveRecord::Base.establish_connection(config)
+  #     puts ActiveRecord::Base.connection.charset
+  #   else
+  #     puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+  #   end
+  # end
+
+  # desc "Retrieves the collation for the current environment's database"
+  # task :collation => :environment do
+  #   config = ActiveRecord::Base.configurations[MERB_ENV || :development]
+  #   case config[:adapter]
+  #   when 'mysql'
+  #     ActiveRecord::Base.establish_connection(config)
+  #     puts ActiveRecord::Base.connection.collation
+  #   else
+  #     puts 'sorry, your database adapter is not supported yet, feel free to submit a patch'
+  #   end
+  # end
+
+  desc "Retrieves the current schema version number"
+  task :version => :environment do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+
+  namespace :fixtures 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|
+        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
+      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
+      file = ENV['SCHEMA'] || "schema/schema.rb"
+      load(file)
+    end
+  end
+
+  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]}'"
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open("schema/#{MERB_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      end
+    end
+  end
+
+  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::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"]}'"
+      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"]}'"
+      end
+    end
+
+    desc 'Prepare the test database and load the schema'
+    task :prepare => :environment 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
+    end
+  end
+
+  namespace :sessions do
+  #  desc "Creates a sessions migration for use with CGI::Session::ActiveRecordStore"
+  #  task :create => :environment do
+  #    raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+  #    require 'rails_generator'
+  #    require 'rails_generator/scripts/generate'
+  #    Rails::Generator::Scripts::Generate.new.run(["session_migration", ENV["MIGRATION"] || "AddSessions"])
+  #  end
+
+    desc "Clear the sessions table"
+    task :clear => :environment do
+      session_table = 'session'
+      session_table = Inflector.pluralize(session_table) if ActiveRecord::Base.pluralize_table_names
+      ActiveRecord::Base.connection.execute "DELETE FROM #{session_table}"
+    end
+  end
+end
+
+def session_table_name
+  ActiveRecord::Base.pluralize_table_names ? :sessions : :session
+end
+
+def set_firebird_env(config)
+  ENV["ISC_USER"]     = config["username"].to_s if config["username"]
+  ENV["ISC_PASSWORD"] = config["password"].to_s if config["password"]
+end
+
+def firebird_db_string(config)
+  FireRuby::Database.db_string_for(config.symbolize_keys)
+end

data/lib/merb/session/active_record_session.rb

@@ -0,0 +1,128 @@
+require 'active_record'
+
+module Merb
+  module SessionMixin
+    def setup_session
+      MERB_LOGGER.info("Setting up session")
+      before = cookies[_session_id_key]
+      @_session, cookies[_session_id_key] = Merb::ActiveRecordSession.persist(cookies[_session_id_key])
+      @_fingerprint = Marshal.dump(@_session.data).hash
+      @_new_cookie = cookies[_session_id_key] != before
+    end
+
+    def finalize_session
+      MERB_LOGGER.info("Finalize session")
+      @_session.save if @_fingerprint != Marshal.dump(@_session.data).hash
+      set_cookie(_session_id_key, @_session.session_id, _session_expiry) if (@_new_cookie || @_session.needs_new_cookie)
+    end
+  end # ActiveRecordMixin
+
+  class ActiveRecordSession < ::ActiveRecord::Base
+    set_table_name 'sessions'
+    # Customizable data column name.  Defaults to 'data'.
+    cattr_accessor :data_column_name
+    self.data_column_name = 'data'
+    before_save :marshal_data!
+    before_save :raise_on_session_data_overflow!
+    attr_accessor :needs_new_cookie
+
+    class << self
+      # Generates a new session ID and creates a row for the new session in the database.
+      def generate
+        create(:session_id => Merb::SessionMixin::rand_uuid, :data => {})
+      end
+
+      # Gets the existing session based on the <tt>session_id</tt> available in cookies.
+      # If none is found, generates a new session.
+      def persist(session_id)
+        if session_id
+          session = find_by_session_id(session_id)
+        end
+        unless session
+          session = generate
+        end
+        [session, session.session_id]
+      end
+    
+      # Don't try to reload ARStore::Session in dev mode.
+      def reloadable? #:nodoc:
+        false
+      end
+
+      def data_column_size_limit
+        @data_column_size_limit ||= columns_hash[@@data_column_name].limit
+      end
+
+      def marshal(data)   Base64.encode64(Marshal.dump(data)) if data end
+      def unmarshal(data) Marshal.load(Base64.decode64(data)) if data end
+
+      def create_table!
+        connection.execute <<-end_sql
+          CREATE TABLE #{table_name} (
+            id INTEGER PRIMARY KEY,
+            #{connection.quote_column_name('session_id')} TEXT UNIQUE,
+            #{connection.quote_column_name(@@data_column_name)} TEXT(255)
+          )
+        end_sql
+      end
+
+      def drop_table!
+        connection.execute "DROP TABLE #{table_name}"
+      end
+    end
+  
+    # Regenerate the Session ID
+    def regenerate
+      update_attributes(:session_id => Merb::SessionMixin::rand_uuid)
+      self.needs_new_cookie = true
+    end 
+   
+    # Recreates the cookie with the default expiration time 
+    # Useful during log in for pushing back the expiration date 
+    def refresh_expiration
+      self.needs_new_cookie = true
+    end 
+  
+    # Lazy-delete of session data 
+    def delete
+      self.data = {}
+    end
+  
+    def [](key)
+      data[key]
+    end
+  
+    def []=(key, val)
+      data[key] = val
+    end
+    
+    # Lazy-unmarshal session state.
+    def data
+      @data ||= self.class.unmarshal(read_attribute(@@data_column_name)) || {}
+    end
+
+    # Has the session been loaded yet?
+    def loaded?
+      !! @data
+    end
+
+    private
+      attr_writer :data
+
+      def marshal_data!
+        return false if !loaded?
+        write_attribute(@@data_column_name, self.class.marshal(self.data))
+      end
+
+      # Ensures that the data about to be stored in the database is not
+      # larger than the data storage column. Raises
+      # ActionController::SessionOverflowError.
+      def raise_on_session_data_overflow!
+        return false if !loaded?
+        limit = self.class.data_column_size_limit
+        if loaded? and limit and read_attribute(@@data_column_name).size > limit
+          raise MerbController::SessionOverflowError
+        end
+      end
+  end # ActiveRecordSessionMixin
+end # Merb

data/lib/merb_activerecord.rb

@@ -0,0 +1,11 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  if Merb::Server.app_loaded?
+    puts "Warning: The merb_active_record gem must be loaded before the application"
+  else
+    require "merb/orms/active_record/connection"
+    Merb::Orms::ActiveRecord.connect
+    Merb::Orms::ActiveRecord.register_session_type
+  end
+  Merb::Plugins.add_rakefiles "merb/orms/active_record/tasks/databases"
+end

data/specs/merb_active_record_spec.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "merb_active_record" do
+  it "should do nothing" do
+    true.should == true
+  end
+end

data/specs/spec_helper.rb

@@ -0,0 +1,2 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: merb_activerecord
+version: !ruby/object:Gem::Version 
+  version: 0.4.2
+date: 2007-11-06 00:00:00 -06:00
+summary: Merb plugin that provides ActiveRecord support for Merb
+require_paths: 
+- lib
+email: canadaduane@gmail.com
+homepage: http://merbivore.com
+rubyforge_project: 
+description: Merb plugin that provides ActiveRecord support for Merb
+autorequire: merb_activerecord
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Duane Johnson
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb
+- lib/merb_activerecord.rb
+- lib/merb/orms
+- lib/merb/session
+- lib/merb/orms/active_record
+- lib/merb/orms/active_record/connection.rb
+- lib/merb/orms/active_record/database.sample.yml
+- lib/merb/orms/active_record/tasks
+- lib/merb/orms/active_record/tasks/databases.rb
+- lib/merb/session/active_record_session.rb
+- specs/merb_active_record_spec.rb
+- specs/spec_helper.rb
+- activerecord_generators/database_sessions_migration
+- activerecord_generators/migration
+- activerecord_generators/model
+- activerecord_generators/resource_controller
+- activerecord_generators/database_sessions_migration/database_sessions_migration_generator.rb
+- activerecord_generators/database_sessions_migration/templates
+- activerecord_generators/database_sessions_migration/USAGE
+- activerecord_generators/database_sessions_migration/templates/sessions_migration.erb
+- activerecord_generators/migration/migration_generator.rb
+- activerecord_generators/migration/templates
+- activerecord_generators/migration/USAGE
+- activerecord_generators/migration/templates/new_migration.erb
+- activerecord_generators/model/model_generator.rb
+- activerecord_generators/model/templates
+- activerecord_generators/model/USAGE
+- activerecord_generators/model/templates/new_model.erb
+- activerecord_generators/resource_controller/resource_controller_generator.rb
+- activerecord_generators/resource_controller/templates
+- activerecord_generators/resource_controller/USAGE
+- activerecord_generators/resource_controller/templates/controller.rb
+- activerecord_generators/resource_controller/templates/edit.html.erb
+- activerecord_generators/resource_controller/templates/helper.rb
+- activerecord_generators/resource_controller/templates/index.html.erb
+- activerecord_generators/resource_controller/templates/new.html.erb
+- activerecord_generators/resource_controller/templates/show.html.erb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: