secondbase 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "activerecord", "~> 3.0.0"
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activerecord (3.0.0)
+      activemodel (= 3.0.0)
+      activesupport (= 3.0.0)
+      arel (~> 1.0.0)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.0)
+    arel (1.0.1)
+      activesupport (~> 3.0.0)
+    builder (2.1.2)
+    git (1.2.5)
+    i18n (0.4.1)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    shoulda (2.11.1)
+    tzinfo (0.3.23)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.0)
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 karledurante
+
+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.rdoc

@@ -0,0 +1,108 @@
+= secondbase
+
+SecondBase adds a second database to your application.  While Rails enables you to establish connections to as many external databases as you like, Rails can only manage a single database with it's migration and testing tasks.
+
+Secondbase enables Rails to work with, and manage, a second database (almost) transparently.  As a developer, you should not even realize a second database is in play.  Core rake tasks such as db:create, db:migrate, and test will continue to work seamlessly with both databases without you, the developer, having to run any extra rake tasks.
+
+== Contributing to secondbase
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== System Requirements
+Secondbase requires Rails 3.x.  This is mainly because it was easier to include the rake tasks into your Rails application root.  With that being said, it would not be hard to port this to Rails 2.x, you simply need to manually modify your Rakefile to require 'secondbase/tasks'.  
+
+If you have the time to update this gem to be backward compatible, by all means...
+
+
+== Installation
+Modify your Gemfile to include Secondbase:
+  
+  gem 'secondbase', '0.1.0'
+
+Run `bundle install`.  You thought it would be harder?
+
+== Usage
+=== Database
+- setting up database.yml
+
+
+=== Migrations
+SecondBase comes with a generator to assist in managing your migrations
+ 
+  rails generator secondbase:migration CreateWidgetsTable
+
+The generator will organize your second (data)base migrations alongside of your primary database.  The above command will generate the file:
+
+  db/migrate/secondbase/20101203211338_create_widgets_table.rb
+  
+To run your migrations, simply run:
+
+  rake db:migrate
+  
+This will migrate your first and second (data)bases.  If, for some reason, you only want to migrate your second (data)base, run:
+
+  rake db:migrate:secondbase
+  
+Please note that migrating up and migrating down must be done specifically on your first or second (data)base.  As usual, to migrate your first (data)base up or down to version 20101203211338, you could run:
+
+  rake db:migrate:up VERSION=20101005311335
+  rake db:migrate:down VERSION=20101005311335
+
+To migrate your second (data)base up or down to version 20101203211338, you would run:
+
+  rake db:migrate:up:secondbase VERSION=20101203211338
+  rake db:migrate:down:secondbase VERSION=20101203211338
+
+
+=== Models
+Every model in your project that extends ActiveRecord::Base will point to the database defined by Rails.env.  This is the default Rails behavior and should be of no surprise to you.  So how do we point our models to the second (data)base?
+
+SecondBase offers a base model that you can simply extend:
+  
+  require 'secondbase/model'
+  
+  class Widget < SecondBase::Base
+    # you're Widget model is now pointing to your second (data)base table 'widgets'
+  end
+
+=== Rake Tasks & Custom Classes
+If you need to write rake tasks, or some other code that does not extend ActiveRecord, you can simply establish a connection to your second (data)base:
+
+  SecondBase::has_runner(Rails.env)
+  
+Please note that this is equivalent to using ActiveRecord::Base.establish_connection(config) and will reset the base connection of your ENTIRE application.  No worries, to move the runner back to first you can use:
+
+  FirstBase::has_runner(Rails.env)
+
+=== Testing
+Tests can still be run using `rake test` or `rake test:units`, etc.  However, if you are using fixtures, you will need to update your TestHelper class to include:
+
+  require 'secondbase/fixtures'
+  
+This is patch to fixtures that will identify the fixtures which belong to models that extend SecondBase::Base.  The patch will then ensure that the table descendants of SecondBase::Base get loaded into your second test (data)base.
+
+At this time, there is not support for anything other than fixtures (i.e. factories).  If you have the time to update this gem to be test object compatible, by all means...
+
+== TODO
+- We should support Rails 2.x as well as 3.x 
+
+- Migration generator needs support for attribute generation (similar to rails generate migration).  For example:
+  `rails generate secondbase_migration AddTitleBodyToPost title:string body:text published:boolean`
+
+- rake db:fixtures:load is currently broken.  Like many other things I have fixed, it assumes you only one a single database and attempts to load all fixtures into it.  I don't believe we can get away with alias chaining this one, I think (like the Fixtures class), we'll have to freedom patch it.
+
+- secondbase should provide support for testing objects other then fixtures
+
+- TESTS!!  Not 100% sure how to test the rake tasks, but I can definitely write tests for the classes and generators. I did this in my spare time, sorry...
+
+== Copyright
+
+Copyright (c) 2010 karledurante. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "secondbase"
+  gem.homepage = "http://github.com/karledurante/secondbase"
+  gem.license = "MIT"
+  gem.summary = %Q{Allow Rails manage second database in your projects}
+  gem.description = %Q{Secondbase provides support to Rails to create a homogeneous for a dual database project.  Using the rake tasks already familiar to you, this gem enables Rails to work with two primary databases, instead of just one.}
+  gem.email = "kdurante@customink.com"
+  gem.authors = ["karledurante"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "secondbase #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/generators/secondbase/USAGE

@@ -0,0 +1,34 @@
+Description:
+    Stubs out a new (second)database migration. Pass the migration name, either
+    CamelCased or under_scored, and an optional list of attribute pairs as arguments.
+
+    For your organizational convenience, a migration class is generated in 
+    db/migrate/secondbase prefixed by a timestamp of the current date and time.
+
+    You can name your migration in either of these formats to generate add/remove
+    column lines from supplied attributes: AddColumnsToTable or RemoveColumnsFromTable
+
+Example:
+    `rails generate secondbase_migration AddSslFlag`
+
+    If the current date is May 14, 2008 and the current time 09:09:12, this creates the AddSslFlag migration
+    db/migrate/secondbase/20080514090912_add_ssl_flag.rb
+
+    `rails generate secondbase_migration AddTitleBodyToPost title:string body:text published:boolean`
+    
+    This will create the AddTitleBodyToPost in db/migrate/secondbase/20080514090912_add_title_body_to_post.rb with
+    this in the Up migration:
+
+      add_column :posts, :title, :string  
+      add_column :posts, :body, :text  
+      add_column :posts, :published, :boolean
+
+    And this in the Down migration:
+    
+      remove_column :posts, :published  
+      remove_column :posts, :body  
+      remove_column :posts, :title
+
+    You can continue to use `rake db:migrate` to migrate your first and second databases, or you can 
+    target secondbase by using `rake db:migrate:secondbase`.  Remember, your migrations are timestamped, 
+    so regardless of the database they target, they will be unique and you will not have collision issues.

data/lib/generators/secondbase/migration_generator.rb

@@ -0,0 +1,38 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'active_record'
+
+module Secondbase
+  class MigrationGenerator < Rails::Generators::NamedBase
+    include Rails::Generators::Migration
+
+    def self.source_root
+      File.join(File.dirname(__FILE__), 'templates')
+    end
+
+     # Implement the required interface for Rails::Generators::Migration.
+     # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+    def self.next_migration_number(dirname) #:nodoc:
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+      end
+    end
+
+    def create_migration_file
+      migration_template 'migration.rb', 
+                          "db/migrate/#{SecondBase::CONNECTION_PREFIX}/#{class_name.underscore}.rb", 
+                          :assigns => get_local_assigns
+    end
+    
+    private 
+    # TODO: We need to add support for name/value pairs like title:string dob:date etc..
+    def get_local_assigns
+      returning(assigns = {}) do
+        assigns[:class_name] = class_name
+      end
+    end
+        
+  end
+end

data/lib/generators/secondbase/templates/migration.rb

@@ -0,0 +1,13 @@
+class <%= class_name.underscore.camelize %> < ActiveRecord::Migration
+  ############################################################
+  # Database migration targeting the SecondBase!
+  # Generated using: rails generator secondbase:migration [MigrationName]
+  
+  def self.up
+    
+  end
+
+  def self.down
+    
+  end
+end

data/lib/secondbase.rb

@@ -0,0 +1,32 @@
+require 'active_record'
+
+module SecondBase
+  CONNECTION_PREFIX = 'secondbase'
+  
+  require 'secondbase/railtie' if defined?(Rails)
+  require 'secondbase/rake_method_chain'
+  
+  def self.do
+    "You have just gotten to SecondBase, my friend."
+  end
+  
+  
+  def self.has_runner(env)
+    ActiveRecord::Base.establish_connection(SecondBase::config(env))
+  end
+
+  def self.config(env)
+    ActiveRecord::Base.configurations[SecondBase::CONNECTION_PREFIX][env]
+  end
+
+end
+
+module FirstBase
+  def self.config(env)
+    ActiveRecord::Base.configurations[env]
+  end
+  
+  def self.has_runner(env)
+    ActiveRecord::Base.establish_connection(FirstBase::config(env))
+  end
+end

data/lib/secondbase/fixtures.rb

@@ -0,0 +1,68 @@
+require 'secondbase/model'
+
+###########################
+# Monkey patch Fixtures
+# Fixtures needs to load fixtures into the database defined by the parent class!
+#
+# I feel like the concepts here could be incorporated directly into Fixtures. 
+# I mean, they shouldn't be so presumptions to think that every model lives in the 
+# same database....
+class Fixtures
+  def self.create_fixtures(fixtures_directory, table_names, class_names = {})
+    table_names = [table_names].flatten.map { |n| n.to_s }
+    table_names.each { |n| class_names[n.tr('/', '_').to_sym] = n.classify if n.include?('/') }
+    connection  = block_given? ? yield : ActiveRecord::Base.connection
+    
+    # make sure we only load secondbase tables that have fixtures defined...
+    sb_table_names = SecondBase::Base.send(:descendants).map(&:table_name)
+    sb_table_names = sb_table_names & table_names
+    sb_connection = SecondBase::Base.connection                          
+    
+    # filter out the secondbase tables from firstbase, otherwise we'll get SQL errors...
+    table_names_to_fetch = table_names.reject { |table_name| fixture_is_cached?(connection, table_name) || sb_table_names.include?(table_name) }
+    fixtures = process_fixture_table_names(table_names_to_fetch, class_names, connection, fixtures_directory)
+    fixtures = [fixtures] if !fixtures.instance_of?(Array)
+    
+    sb_table_names_to_fetch = sb_table_names.reject { |table_name| fixture_is_cached?(sb_connection, table_name)}
+    sb_fixtures = process_fixture_table_names(sb_table_names_to_fetch, class_names, sb_connection, fixtures_directory)
+    sb_fixtures = [sb_fixtures] if !sb_fixtures.instance_of?(Array)
+    
+    (fixtures + sb_fixtures).compact
+  end
+  
+  def self.process_fixture_table_names(table_names_to_fetch, class_names, connection, fixtures_directory)
+    fixtures_map = {}
+    unless table_names_to_fetch.empty?
+      ActiveRecord::Base.silence do
+        connection.disable_referential_integrity do
+          # fixtures_map = {}
+
+          fixtures = table_names_to_fetch.map do |table_name|
+            obj = Fixtures.new(connection, table_name.tr('/', '_'), class_names[table_name.tr('/', '_').to_sym], File.join(fixtures_directory, table_name))
+            fixtures_map[table_name] = obj
+          end
+
+          all_loaded_fixtures.update(fixtures_map)
+
+          connection.transaction(:requires_new => true) do
+            fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
+            fixtures.each { |fixture| fixture.insert_fixtures }
+
+            # Cap primary key sequences to max(pk).
+            if connection.respond_to?(:reset_pk_sequence!)
+              table_names_to_fetch.each do |table_name|
+                connection.reset_pk_sequence!(table_name.tr('/', '_'))
+              end
+            end
+          end
+
+          cache_fixtures(connection, fixtures_map)
+        end
+      end
+    end
+    
+    table_names_to_fetch = nil if table_names_to_fetch.blank?
+    cached_fixtures(connection, table_names_to_fetch)
+  end
+
+end

data/lib/secondbase/model.rb

@@ -0,0 +1,12 @@
+# Secondbase model definition
+#
+# NOTE: By extending this model, you assume that the underlying table will be located in your Second (Data)base
+module SecondBase
+  require 'active_record'
+  
+  class Base < ActiveRecord::Base
+    establish_connection ActiveRecord::Base.configurations[CONNECTION_PREFIX][Rails.env]
+  
+    self.abstract_class = true
+  end
+end

data/lib/secondbase/railtie.rb

@@ -0,0 +1,10 @@
+require 'secondbase'
+require 'rails'
+module SecondBase
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      load "tasks/secondbase.rake"
+    end
+  end
+end

data/lib/secondbase/rake_method_chain.rb

@@ -0,0 +1,22 @@
+require 'rake'
+  
+# We want to provide a way to alias tasks so we can hook our custom logic
+# into the existing rails framework. For more information and usage, see:
+# http://www.metaskills.net/2010/5/26/the-alias_method_chain-of-rake-override-rake-task
+Rake::TaskManager.class_eval do
+  def alias_task(fq_name)
+    new_name = "#{fq_name}:original"
+    @tasks[new_name] = @tasks.delete(fq_name)
+  end
+end
+
+def alias_task(fq_name)
+  Rake.application.alias_task(fq_name)
+end
+
+def override_task(*args, &block)
+  name, params, deps = Rake.application.resolve_args(args.dup)
+  fq_name = Rake.application.instance_variable_get(:@scope).dup.push(name).join(':')
+  alias_task(fq_name)
+  Rake::Task.define_task(*args, &block)
+end

data/lib/tasks/secondbase.rake

@@ -0,0 +1,194 @@
+require 'secondbase'
+####################################
+#                                  
+# SecondBase database managment tasks  
+#
+# We are overriding a handful of rake tasks here:
+# db:create
+# db:migrate
+# db:test:prepare
+#
+# We ARE NOT redefining the implementation of these tasks, we are simply 
+# appending custom functionality to them. We just want to be sure that in 
+# addition to creating, migrating, and preparing your default (Rails.env) 
+# database, that we can also work with with the second (data)base. 
+  
+namespace :db do
+  override_task :create do
+    # First, we execute the original/default create task
+    Rake::Task["db:create:original"].invoke
+    
+    # now, we create our secondary databases
+    Rake::Task['environment'].invoke
+    ActiveRecord::Base.configurations[SecondBase::CONNECTION_PREFIX].each_value do |config|
+      next unless config['database']
+      
+      # Only connect to local databases
+      local_database?(config) { create_database(config) }
+    end
+  end
+  
+  override_task :migrate do
+    Rake::Task['environment'].invoke
+    
+    # Migrate secondbase...
+    Rake::Task["db:migrate:secondbase"].invoke
+    
+    # Execute the original/default prepare task 
+    Rake::Task["db:migrate:original"].invoke
+  end
+  
+  namespace :test do
+    override_task :prepare do
+      Rake::Task['environment'].invoke
+      
+      # Clone the secondary database structure
+      Rake::Task["db:test:prepare:secondbase"].invoke
+      
+      # Execute the original/default prepare task 
+      Rake::Task["db:test:prepare:original"].invoke
+    end
+  end
+  
+  ##################################
+  # SecondBase specific database tasks 
+  namespace :migrate do
+    desc "migrates the second database"
+    task :secondbase => :load_config do
+      Rake::Task['environment'].invoke
+      # NOTE: We are not generating a db schema on purpose.  Since we're running 
+      # in a dual db mode, it could be confusing to have two schemas.
+      
+      # reset connection to secondbase...
+      use_secondbase(Rails.env)
+      
+      # run secondbase migrations...
+      ActiveRecord::Migration.verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
+      ActiveRecord::Migrator.migrate("db/migrate/#{SecondBase::CONNECTION_PREFIX}/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+      
+      # reset connection back to firstbase...
+      use_firstbase(Rails.env)
+    end
+    
+    namespace :up do
+      desc 'Runs the "up" for a given SecondBase migration VERSION.'
+      task :secondbase => :environment do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        
+        # reset connection to secondbase...
+        use_secondbase(Rails.env)
+        
+        ActiveRecord::Migrator.run(:up, "db/migrate/#{SecondBase::CONNECTION_PREFIX}/", version)
+        
+        # reset connection back to firstbase...
+        use_firstbase(Rails.env)
+      end
+    end
+    
+    namespace :down do
+      desc 'Runs the "down" for a given SecondBase migration VERSION.'
+      task :secondbase => :environment do
+        version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
+        raise "VERSION is required" unless version
+        
+        # reset connection to secondbase...
+        use_secondbase(Rails.env)
+        
+        ActiveRecord::Migrator.run(:down, "db/migrate/#{SecondBase::CONNECTION_PREFIX}/", version)
+        
+        # reset connection back to firstbase...
+        use_firstbase(Rails.env)
+      end
+    end
+  end
+  
+  namespace :create do
+    desc 'Create the database defined in config/database.yml for the current RAILS_ENV'
+    task :secondbase => :load_config do
+      
+      # We can still use the #create_database method defined in activerecord's databases.rake
+      # we call it passing the secondbase config instead of the default (Rails.env) config...
+      create_database(secondbase_config(Rails.env))
+    end
+  end
+  
+  namespace :structure do
+    namespace :dump do
+      desc "dumps structure for both (first and second) databases."
+      task :secondbase do
+        Rake::Task['environment'].invoke
+        
+        # we want to dump the development (second)database....
+        use_secondbase('development')
+        
+        File.open("#{RAILS_ROOT}/db/#{SecondBase::CONNECTION_PREFIX}_#{RAILS_ENV}_structure.sql", "w+") do |f| 
+          f << ActiveRecord::Base.connection.structure_dump
+        end
+        
+        use_firstbase(Rails.env)
+      end 
+    end
+  end
+
+  namespace :test do
+    namespace :prepare do
+      desc 'Prepares the test instance of secondbase'
+      task :secondbase do
+        Rake::Task["db:test:clone_structure:secondbase"].invoke
+      end
+    end
+    
+    namespace :purge do
+      task :secondbase do
+        Rake::Task['environment'].invoke    
+        
+        use_secondbase('test')
+        
+        ActiveRecord::Base.connection.recreate_database(secondbase_config('test')["database"], secondbase_config('test')) 
+        
+        use_firstbase(Rails.env)
+      end
+    end
+
+    namespace :clone_structure do
+      task :secondbase do
+        Rake::Task['environment'].invoke
+        
+        # dump secondbase structure and purge the test secondbase
+        `rake db:structure:dump:secondbase`
+        `rake db:test:purge:secondbase`
+
+        # now lets clone the structure for secondbase
+        use_secondbase('test')
+        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+        IO.readlines("#{RAILS_ROOT}/db/#{SecondBase::CONNECTION_PREFIX}_#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
+          ActiveRecord::Base.connection.execute(table)
+        end
+        
+        use_firstbase(Rails.env)
+      end
+    end
+  end
+
+end
+
+
+####################################
+# 
+# Some helper methods to run back and forth between first and second base.
+def use_firstbase(env)
+  ActiveRecord::Base.establish_connection(firstbase_config(env))
+end
+
+def use_secondbase(env)
+  ActiveRecord::Base.establish_connection(secondbase_config(env))
+end
+
+def secondbase_config(env)
+  ActiveRecord::Base.configurations[SecondBase::CONNECTION_PREFIX][env]
+end
+
+def firstbase_config(env)
+  ActiveRecord::Base.configurations[env]
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'secondbase'
+
+class Test::Unit::TestCase
+end

data/test/test_secondbase.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestSecondbase < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: secondbase
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- karledurante
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-06 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: shoulda
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: bundler
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: jeweler
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  name: activerecord
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  requirement: *id004
+description: Secondbase provides support to Rails to create a homogeneous for a dual database project.  Using the rake tasks already familiar to you, this gem enables Rails to work with two primary databases, instead of just one.
+email: kdurante@customink.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/generators/secondbase/USAGE
+- lib/generators/secondbase/migration_generator.rb
+- lib/generators/secondbase/templates/migration.rb
+- lib/secondbase.rb
+- lib/secondbase/fixtures.rb
+- lib/secondbase/model.rb
+- lib/secondbase/railtie.rb
+- lib/secondbase/rake_method_chain.rb
+- lib/tasks/secondbase.rake
+- test/helper.rb
+- test/test_secondbase.rb
+has_rdoc: true
+homepage: http://github.com/karledurante/secondbase
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Allow Rails manage second database in your projects
+test_files: 
+- test/helper.rb
+- test/test_secondbase.rb