ccls-use_db 0.9.3

data/README.rdoc

@@ -0,0 +1,101 @@
+= UseDb
+by David Stevenson
+ds@elctech.com
+
+== USAGE
+
+This plugin allows you to use multiple databases in your rails application.  
+You can switch the database for a model in the following manner:
+
+ class MyModel < ActiveRecord::Base
+   use_db :prefix => "secdb_", :suffix => "_cool"
+ end
+
+"use_db" takes a prefix and a suffix (only 1 of which is required) which are prepended and appended onto the current RAILS_ENV.  
+In the above example, I would have to make the following database entries to my database.yml:
+
+ secdb_development_cool:
+   adapter: mysql
+   database: secdb_dev_db
+   ...
+
+ secdb_test_cool:
+   adapater: mysql
+   database: secdb_test_db
+   ...
+
+It's often useful to create a single abstract model which all models using a different database extend from:
+
+ class SecdbBase < ActiveRecord::Base
+   use_db :prefix => "secdb_"
+   self.abstract_class = true
+ end
+
+ class MyModel < SecdbBase
+   # this model will use a different database automatically now
+ end
+
+== MIGRATIONS
+
+To write a migration which executes on a different database, add the following method to your
+migration:
+
+ class MyMigration < ActiveRecord::Migration
+   def self.database_model
+     return "SecdbBase"
+   end
+
+   def self.up
+     ...
+   end
+
+   ...
+ end
+
+The "self.database_model" call must return a string which is the name of the model whose connection
+you want to borrow when performing the migration.  If this method is undefined, the default ActiveRecord::Base
+connection is used.
+
+== TESTING
+
+In order to test multiple databases, you must invoke a task which clones the development database
+structure and copies it into the test database, clearing out the existing test data.  There is a single
+helper method which executes this task and you invoke it as follows:
+
+ UseDbTest.prepare_test_db(:prefix => "secdb_")
+
+Even though it might not be the best place for it, I often place a call to this in my test helper.
+You don't want it to execute for every test, so put the following guards around it:
+
+ unless defined?(CLONED_SEC_DB_FOR_TEST)
+   UseDbTest.prepare_test_db(:prefix => "secdb_")
+   CLONED_SEC_DB_FOR_TEST = true
+ end
+
+== FIXTURES
+
+Fixtures will automatically be loaded into the correct database as long as the fixture name corresponds
+to the name of a model.  For example, if I have a model called SecdbUser who uses a different database and
+I create a fixture file called secdb_users.yml, the fixture loader will use whatever database connection
+belongs to the SecdbUser model.
+
+There is currently no other way to force a fixture to use a specific database (sorry, no join tables yet),
+like there is for migrations.
+
+
+
+
+== Gemified with Jeweler
+
+ vi Rakefile
+ rake version:write
+
+ rake version:bump:patch
+ rake version:bump:minor
+ rake version:bump:major
+
+ rake gemspec
+
+ rake install
+ rake release
+

data/lib/ccls-use_db.rb

@@ -0,0 +1 @@
+require 'use_db'

data/lib/tasks/use_db_tasks.rake

@@ -0,0 +1,39 @@
+#namespace :db do
+#	namespace :structure do
+#		task :dump_use_db do						
+#			UseDbTest.other_databases.each do |options| 
+#				puts "DUMPING TEST DB: #{options.inspect}" if UseDbPlugin.debug_print
+#				UseDbTest.dump_db_structure(options)
+#			end
+#		end
+#	end
+#	
+#	namespace :test do
+#		task :clone_structure => "db:test:clone_structure_use_db"
+#
+#		task :clone_structure_use_db => ["db:structure:dump_use_db","db:test:purge_use_db"] do
+#			UseDbTest.other_databases.each do |options|	 
+#				puts "CLONING TEST DB: #{options.inspect}" if UseDbPlugin.debug_print
+#				UseDbTest.clone_db_structure(options)
+#			end
+#		end
+#		
+#		task :purge_use_db => "db:test:purge" do
+#			UseDbTest.other_databases.each do |options|
+#				puts "PURGING TEST DB: #{options.inspect}" if UseDbPlugin.debug_print
+#				UseDbTest.purge_db(options)
+#			end
+#		end	
+#	end
+#end
+
+require 'use_db'
+#	without this, the extra databases don't load
+#	I'd like to find another way though
+Rake::Task[:rails_env].prerequisites.unshift(:environment )
+
+#namespace :test do
+#	task :units => "db:test:clone_structure_use_db"
+#	task :functionals => "db:test:clone_structure_use_db"
+#	task :integrations => "db:test:clone_structure_use_db"
+#end

data/lib/use_db.rb

@@ -0,0 +1,13 @@
+module UseDb
+#	predefine namespace
+end
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_record/migration'
+require 'use_db/configurations'
+require 'use_db/use_db_plugin'
+require 'use_db/use_db_test'
+require 'use_db/test_model'
+require 'use_db/override_fixtures'
+require 'use_db/override_test_case'
+require 'use_db/migration'

data/lib/use_db/configurations.rb

@@ -0,0 +1,35 @@
+#
+#	include the other (potential) database.yml files
+#
+module UseDb::Configurations
+
+	def self.included(base)
+		unless base.respond_to?(:configurations_with_other_dbs)
+			base.extend(ClassMethods)
+			base.class_eval do
+				class << self
+					alias_method_chain :configurations, :other_dbs
+				end
+			end
+		end
+	end
+
+	module ClassMethods
+
+		def configurations_with_other_dbs
+#			puts "In configurations with other dbs"
+			if configurations_without_other_dbs.empty?
+				#	for rake tasks
+				configurations_without_other_dbs.update(YAML::load(ERB.new(IO.read(
+					File.join( Rails.root,'config','database.yml'))).result))
+			end
+			OTHER_DB_FILES.each do |f|
+				configurations_without_other_dbs.update(YAML::load(ERB.new(IO.read(f)).result))
+			end if defined?(OTHER_DB_FILES)
+			configurations_without_other_dbs
+		end
+
+	end
+
+end
+ActiveRecord::Base.send(:include,UseDb::Configurations)

data/lib/use_db/migration.rb

@@ -0,0 +1,89 @@
+module UseDb::Migration
+
+	def self.included(base)
+		unless base.respond_to?(:method_missing_without_connection_swap)
+			base.extend(ClassMethods)
+			base.class_eval do
+				class << self
+					alias_method_chain :method_missing, :connection_swap
+				end
+			end 
+		end 
+	end
+
+	module ClassMethods
+
+		def method_missing_with_connection_swap(method, *arguments, &block)
+			say_with_time "#{method}(#{arguments.map { |a| a.inspect }.join(", ")})" do
+				arguments[0] = ActiveRecord::Migrator.proper_table_name(arguments.first
+					) unless arguments.empty? || method == :execute
+				if (self.respond_to?(:database_model))
+					write "Using custom database model's connection (#{self.database_model}) for this migration"
+					eval("#{self.database_model}.connection.send(method, *arguments, &block)")
+				else
+					ActiveRecord::Base.connection.send(method, *arguments, &block)
+#					method_missing_without_connection_swap(method, *arguments, &block)
+				end
+			end
+		end
+
+		def uses_db?
+			true
+		end
+
+	end
+
+end
+ActiveRecord::Migration.send(:include,UseDb::Migration)
+
+module UseDb::Migrator
+
+	def self.included(base)
+		unless base.respond_to?(:get_all_versions_without_connection_swap)
+			base.extend(ClassMethods)
+			base.alias_method_chain( :record_version_state_after_migrating, :connection_swap
+				) unless base.methods.include?(:record_version_state_after_migrating_without_connection_swap)
+			base.class_eval do
+				class << self
+					alias_method_chain :get_all_versions, :connection_swap
+				end
+			end 
+		end 
+	end
+
+	module ClassMethods
+
+		def get_all_versions_with_connection_swap
+#			puts "in use_db get_all_versions"
+#			Base.connection.select_values("SELECT version FROM #{schema_migrations_table_name}").map(&:to_i).sort
+			UseDbPlugin.all_use_dbs.collect(&:connection).collect{|c|
+				c.initialize_schema_migrations_table	# in case it doesn't exist
+				c.select_values("SELECT version FROM #{schema_migrations_table_name}").map(&:to_i)
+			}.flatten.uniq.sort
+		end
+
+	end
+
+	def record_version_state_after_migrating_with_connection_swap(version)
+		just_migrated = migrations.detect { |m| m.version == version }
+		load(just_migrated.filename)
+		migration_model = just_migrated.name.constantize
+		if migration_model.respond_to?(:database_model)
+			ar_model = migration_model.database_model.constantize
+			ar_model.connection.initialize_schema_migrations_table
+			sm_table = self.class.schema_migrations_table_name
+			@migrated_versions ||= []
+			if down?
+				@migrated_versions.delete(version.to_i)
+				ar_model.connection.update("DELETE FROM #{sm_table} WHERE version = '#{version}'")
+			else
+				@migrated_versions.push(version.to_i).sort!
+				ar_model.connection.insert("INSERT INTO #{sm_table} (version) VALUES ('#{version}')")
+			end
+		else
+			record_version_state_after_migrating_without_connection_swap(version)
+		end
+	end
+
+end
+ActiveRecord::Migrator.send(:include,UseDb::Migrator)

data/lib/use_db/override_fixtures.rb

@@ -0,0 +1,18 @@
+#
+#	Put the fixtures in the correct database
+#
+module UseDb::Fixtures
+
+	def self.included(base)
+		unless base.respond_to?(:read_fixture_files_without_connection_set)
+			base.alias_method_chain :read_fixture_files, :connection_set
+		end
+	end
+
+	def read_fixture_files_with_connection_set
+		@connection = (model_class||ActiveRecord::Base).connection
+		read_fixture_files_without_connection_set
+	end
+
+end
+Fixtures.send(:include,UseDb::Fixtures)

data/lib/use_db/override_test_case.rb

@@ -0,0 +1,63 @@
+#
+#	setup and teardown fixtures in all databases
+#
+module UseDb::TestFixtures
+
+	def self.included(base)
+		base.alias_method_chain :setup_fixtures, :use_db
+		base.alias_method_chain :teardown_fixtures, :use_db
+	end
+
+	def setup_fixtures_with_use_db
+		UseDbPlugin.all_use_dbs.collect do |klass|
+			return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+
+			if pre_loaded_fixtures && !use_transactional_fixtures
+				raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
+			end 
+
+			@fixture_cache = {}
+			@@already_loaded_fixtures ||= {}
+
+			# Load fixtures once and begin transaction.
+			if run_in_transaction?
+				if @@already_loaded_fixtures[self.class]
+					@loaded_fixtures = @@already_loaded_fixtures[self.class]
+				else
+					load_fixtures
+					@@already_loaded_fixtures[self.class] = @loaded_fixtures
+				end 
+				klass.connection.increment_open_transactions
+				klass.connection.transaction_joinable = false
+				klass.connection.begin_db_transaction
+			# Load fixtures for every test.
+			else
+				Fixtures.reset_cache
+				@@already_loaded_fixtures[self.class] = nil 
+				load_fixtures
+			end 
+
+			# Instantiate fixtures for every test if requested.
+			instantiate_fixtures if use_instantiated_fixtures
+		end
+	end
+
+	def teardown_fixtures_with_use_db
+		UseDbPlugin.all_use_dbs.collect do |klass|
+			return unless defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+
+			unless run_in_transaction?
+				Fixtures.reset_cache
+			end
+
+			# Rollback changes if a transaction is active.
+			if run_in_transaction? && klass.connection.open_transactions != 0
+				klass.connection.rollback_db_transaction
+				klass.connection.decrement_open_transactions
+			end
+			klass.clear_active_connections!
+		end
+	end
+
+end
+ActiveRecord::TestFixtures.send(:include,UseDb::TestFixtures)

data/lib/use_db/tasks.rb

@@ -0,0 +1,2 @@
+require 'use_db'
+Dir["#{File.dirname(__FILE__)}/../tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/use_db/test_model.rb

@@ -0,0 +1,11 @@
+def create_test_model(model_name, prefix="", suffix="", rails_env=RAILS_ENV)
+	# puts "Creating test model '#{model_name}', :prefix => '#{prefix}', :suffix => '#{suffix}'"
+	str = <<-EOF
+	require "use_db"
+	
+		class #{model_name} < ActiveRecord::Base
+			use_db :prefix => "#{prefix}", :suffix => "#{suffix}", :rails_env => "#{rails_env}"
+		end
+EOF
+	eval(str)
+end

data/lib/use_db/use_db_plugin.rb

@@ -0,0 +1,63 @@
+module UseDbPlugin
+	# options can have one or the other of the following options:
+	#	 :prefix - Specify the prefix to append to the RAILS_ENV when finding the adapter secification in database.yml
+	#	 :suffix - Just like :prefix, only contactentated
+	# OR
+	#	 :adapter
+	#	 :host
+	#	 :username
+	#	 :password
+	#		 ... etc ... same as the options in establish_connection
+	#	
+	# Set the following to true in your test environment 
+	# to enable extended debugging printing during testing ...
+	# UseDbPlugin.debug_print = true	 
+	#
+	
+	@@use_dbs = [ActiveRecord::Base]
+	@@debug_print = false
+	
+	def use_db(options)
+		options_dup = options.dup
+		conn_spec = get_use_db_conn_spec(options)
+		puts "Establishing connecting on behalf of #{self.to_s} to #{conn_spec.inspect}" if UseDbPlugin.debug_print
+		establish_connection(conn_spec)
+		extend ClassMixin
+		@@use_dbs << self unless @@use_dbs.include?(self) || self.to_s.starts_with?("TestModel")
+	end
+	
+	def self.all_use_dbs
+		return @@use_dbs
+	end
+	
+	def self.debug_print
+		return @@debug_print
+	end
+	
+	def self.debug_print=(newval)
+		@@debug_print = newval
+	end
+	
+	module ClassMixin
+		def uses_db?
+			true
+		end
+	end	
+	
+	def get_use_db_conn_spec(options)
+		options.symbolize_keys!				#	without the bang, this was pointless
+		suffix = options.delete(:suffix)
+		prefix = options.delete(:prefix)
+		rails_env = options.delete(:rails_env) || RAILS_ENV
+		if (options[:adapter])
+			return options
+		else
+			str = "#{prefix}#{rails_env}#{suffix}"
+			connections = ActiveRecord::Base.configurations
+			raise "Cannot find database specification.	Configuration '#{str}' expected in config/database.yml" if (connections[str].nil?)			
+			return connections[str]
+		end
+	end
+
+end
+ActiveRecord::Base.extend(UseDbPlugin)

data/lib/use_db/use_db_test.rb

@@ -0,0 +1,61 @@
+class UseDbTest
+
+	extend UseDbPlugin
+
+	def self.other_databases
+		use_db_config = (defined?(USE_DB_CONFIG)) ? USE_DB_CONFIG : "#{RAILS_ROOT}/config/use_db.yml"
+		YAML.load(File.read(use_db_config)).values.collect(&:symbolize_keys!)
+	end
+
+	def self.prepare_test_db(options={})
+		schema_dump(options)
+		schema_load(options)
+	end
+	
+	def self.schema_dump(options)
+		#	puts "In schema_dump"
+		options_dup = options.dup
+		options_dup[:rails_env] = "development"		
+		conn_spec = get_use_db_conn_spec(options_dup)
+		test_class = setup_test_model(options[:prefix], options[:suffix], "ForSchemaDump")
+		test_class.establish_connection(conn_spec)
+		require 'active_record/schema_dumper'
+		File.open(schema_file(options), "w") do |file|
+			ActiveRecord::SchemaDumper.dump(test_class.connection, file)
+		end
+	end
+
+	def self.schema_load(options)
+		#	puts "In schema_load"
+		options_dup = options.dup
+		conn_spec = get_use_db_conn_spec(options_dup)
+		ActiveRecord::Base.establish_connection(conn_spec)
+		file = schema_file(options)
+#	database.rake suggests that I should purge first, but why?
+#	the schema is :force => true and will wipe everything out anyway.
+#	using schema seems a better option than to the DSL that it came from.
+		if File.exists?(file)
+			#	puts "loading #{file}"
+			ActiveRecord::Schema.verbose = UseDbPlugin.debug_print
+			load(file)
+			ActiveRecord::Base.connection.disconnect!
+			ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations["test"])
+		else
+			abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{RAILS_ROOT}/config/environment.rb to prevent active_record from loading: config.frameworks -= [ :active_record ]}
+		end
+	end
+
+	def self.setup_test_model(prefix="", suffix="", model_suffix="", rails_env=RAILS_ENV)
+		prefix ||= ""
+		suffix ||= ""
+		model_name = "TestModel#{prefix.camelize}#{suffix.camelize}#{model_suffix}".gsub("_","").gsub("-","")
+		return eval(model_name) if eval("defined?(#{model_name})")
+		create_test_model(model_name, prefix, suffix, rails_env)
+		return eval(model_name)
+	end
+
+	def self.schema_file(options)
+		"#{RAILS_ROOT}/db/#{RAILS_ENV}_#{options[:prefix]}_#{options[:suffix]}_schema.rb"
+	end
+
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "ccls-use_db"

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: ccls-use_db
+version: !ruby/object:Gem::Version 
+  hash: 61
+  prerelease: 
+  segments: 
+  - 0
+  - 9
+  - 3
+  version: 0.9.3
+platform: ruby
+authors: 
+- David Stevenson
+- George 'Jake' Wendt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-12 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  type: :runtime
+  version_requirements: *id001
+description: Gem version of use_db rails plugin
+email: github@jakewendt.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- lib/ccls-use_db.rb
+- lib/tasks/use_db_tasks.rake
+- lib/use_db.rb
+- lib/use_db/configurations.rb
+- lib/use_db/migration.rb
+- lib/use_db/override_fixtures.rb
+- lib/use_db/override_test_case.rb
+- lib/use_db/tasks.rb
+- lib/use_db/test_model.rb
+- lib/use_db/use_db_plugin.rb
+- lib/use_db/use_db_test.rb
+- rails/init.rb
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/ccls/use_db
+licenses: []
+
+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.6.2
+signing_key: 
+specification_version: 3
+summary: Gem version of use_db rails plugin
+test_files: []
+