apartment 0.13.0.1 → 0.13.1

data/lib/apartment/adapters/postgresql_adapter.rb

@@ -1,114 +1,115 @@
 module Apartment
-
+  
   module Database
-
+    
     def self.postgresql_adapter(config)
-      Apartment.use_postgres_schemas ?
+      Apartment.use_postgres_schemas ? 
         Adapters::PostgresqlSchemaAdapter.new(config, :schema_search_path => ActiveRecord::Base.connection.schema_search_path) :
         Adapters::PostgresqlAdapter.new(config)
     end
-
+    
   end
-
+  
   module Adapters
-
+    
     # Default adapter when not using Postgresql Schemas
     class PostgresqlAdapter < AbstractAdapter
-
+      
     protected
-
+    
       #   Connect to new database
       #   Abstract adapter will catch generic ActiveRecord error
       #   Catch specific adapter errors here
-      #
+      # 
       #   @param {String} database Database name
-      #
+      # 
       def connect_to_new(database)
         super
-      rescue PGError
+      rescue PGError => e
         raise DatabaseNotFound, "Cannot find database #{environmentify(database)}"
-      end
-
+		  end
+		  
     end
-
+    
     # Separate Adapter for Postgresql when using schemas
     class PostgresqlSchemaAdapter < AbstractAdapter
-
+      
       #   Get the current schema search path
-      #
+      # 
       #   @return {String} current schema search path
-      #
+      # 
       def current_database
         ActiveRecord::Base.connection.schema_search_path
       end
-
+      
       #   Drop the database schema
-      #
+      # 
       #   @param {String} database Database (schema) to drop
-      #
+      # 
       def drop(database)
         ActiveRecord::Base.connection.execute("DROP SCHEMA #{database} CASCADE")
-
-      rescue ActiveRecord::StatementInvalid
+        
+      rescue ActiveRecord::StatementInvalid => e
         raise SchemaNotFound, "The schema #{database.inspect} cannot be found."
       end
 
       #   Reset search path to default search_path
       #   Set the table_name to always use the public namespace for excluded models
-      #
+      # 
       def process_excluded_models
-  	    Apartment.excluded_models.each do |excluded_model|
+        Apartment.excluded_models.each do |excluded_model|
           # Note that due to rails reloading, we now take string references to classes rather than
           # actual object references.  This way when we contantize, we always get the proper class reference
           if excluded_model.is_a? Class
             warn "[Deprecation Warning] Passing class references to excluded models is now deprecated, please use a string instead"
             excluded_model = excluded_model.name
           end
-
+          
           excluded_model.constantize.tap do |klass|
-            # some models (such as delayed_job) seem to load and cache their column names before this,
+            # some models (such as delayed_job) seem to load and cache their column names before this, 
             # so would never get the public prefix, so reset first
-    	      klass.reset_column_information
+            klass.reset_column_information
 
             # Ensure that if a schema *was* set, we override
-      	    table_name = klass.table_name.split('.', 2).last
+            table_name = klass.table_name.split('.', 2).last
 
             # Not sure why, but Delayed::Job somehow ignores table_name_prefix...  so we'll just manually set table name instead
-    				klass.table_name = "public.#{table_name}"
-  				end
-  			end
+            klass.table_name = "public.#{table_name}"
+          end
+        end
       end
-
+      
       #   Reset schema search path to the default schema_search_path
-      #
+      # 
       #   @return {String} default schema search path
-      #
-			def reset
-    		ActiveRecord::Base.connection.schema_search_path = @defaults[:schema_search_path]
-  	  end
+      # 
+      def reset
+        ActiveRecord::Base.connection.schema_search_path = @defaults[:schema_search_path]
+      end
 
-  	protected
+    protected
 
-  	  #   Set schema search path to new schema
-      #
-	    def connect_to_new(database = nil)
-	      return reset if database.nil?
-    		ActiveRecord::Base.connection.schema_search_path = database
+      #   Set schema search path to new schema
+      # 
+      def connect_to_new(database = nil)
+        return reset if database.nil?
+        ActiveRecord::Base.connection.clear_cache!
+        ActiveRecord::Base.connection.schema_search_path = database
 
       rescue ActiveRecord::StatementInvalid => e
         raise SchemaNotFound, "The schema #{database.inspect} cannot be found."
-			end
+      end
 
       #   Create the new schema
-      #
-  	  def create_database(database)
-  	    ActiveRecord::Base.connection.execute("CREATE SCHEMA #{database}")
+      # 
+      def create_database(database)
+        ActiveRecord::Base.connection.execute("CREATE SCHEMA #{database}")
 
-  	  rescue ActiveRecord::StatementInvalid => e
-  		  raise SchemaExists, "The schema #{database} already exists."
+      rescue ActiveRecord::StatementInvalid => e
+        raise SchemaExists, "The schema #{database} already exists."
       end
-
+      
     end
-
+    
   end
 end

data/lib/apartment/database.rb

@@ -1,59 +1,57 @@
 require 'active_support/core_ext/module/delegation'
 
 module Apartment
-
+  
   #   The main entry point to Apartment functions
-  module Database
-
+	module Database
+	  
 	  extend self
 
-    delegate :create, :current_database, :drop, :process, :process_excluded_models, :reset, :seed, :switch, :to => :adapter
-
-    attr_writer :config
+    delegate :create, :current_database, :process, :process_excluded_models, :reset, :seed, :switch, :to => :adapter
 
     #   Initialize Apartment config options such as excluded_models
-    #
-    def init
+    # 
+	  def init
       process_excluded_models
     end
-
+    
     #   Fetch the proper multi-tenant adapter based on Rails config
-    #
+    # 
     #   @return {subclass of Apartment::AbstractAdapter}
-    #
+    # 
     def adapter
 	    @adapter ||= begin
 		    adapter_method = "#{config[:adapter]}_adapter"
-
-        begin
+	    
+		    begin
           require "apartment/adapters/#{adapter_method}"
-        rescue LoadError
+        rescue LoadError => e
           raise "The adapter `#{config[:adapter]}` is not yet supported"
         end
 
         unless respond_to?(adapter_method)
           raise AdapterNotFound, "database configuration specifies nonexistent #{config[:adapter]} adapter"
         end
-
+      
         send(adapter_method, config)
       end
     end
-
+    
     #   Reset config and adapter so they are regenerated
-    #
+    # 
     def reload!
       @adapter = nil
       @config = nil
     end
-
+    
 	private
-
+	
     #   Fetch the rails database configuration
-    #
+    # 
     def config
       @config ||= Rails.configuration.database_configuration[Rails.env].symbolize_keys
     end
-
+    
   end
-
+	
 end

data/lib/apartment/delayed_job/hooks.rb

@@ -3,22 +3,22 @@ require 'apartment/delayed_job/enqueue'
 module Apartment
   module Delayed
     module Job
-
+      
       # Before and after hooks for performing Delayed Jobs within a particular apartment database
       # Include these in your delayed jobs models and make sure provide a @database attr that will be serialized by DJ
       # Note also that any models that are being serialized need the Apartment::Delayed::Requirements module mixed in to it
       module Hooks
-
+        
         attr_accessor :database
-
+        
         def before(job)
           Apartment::Database.switch(job.payload_object.database) if job.payload_object.database
         end
-
+        
         def after
           Apartment::Database.reset
         end
-
+        
       end
     end
   end

data/lib/apartment/elevators/subdomain.rb

@@ -3,41 +3,25 @@ module Apartment
     # Provides a rack based db switching solution based on subdomains
     # Assumes that database name should match subdomain
     class Subdomain
-
+      
       def initialize(app)
         @app = app
       end
-
+      
       def call(env)
-        host = Rack::Request.new(env).host
-
-        database = subdomain(host)
-
+        request = ActionDispatch::Request.new(env)
+        
+        database = subdomain(request)
+        
         Apartment::Database.switch database if database
-
+        
         @app.call(env)
       end
-
-    private
-
-      # *Almost* a direct ripoff of ActionDispatch::Request subdomain methods
-
-      # Only care about the first subdomain for the database name
-      def subdomain(host)
-        subdomains(host).first
+      
+      def subdomain(request)
+        request.subdomain.present? && request.subdomain || nil
       end
-
-      #   Assuming tld_length of 1, might need to make this configurable in Apartment in the future for things like .co.uk
-      def subdomains(host, tld_length = 1)
-        return [] unless named_host?(host)
-
-        host.split('.')[0..-(tld_length + 2)]
-      end
-
-      def named_host?(host)
-        !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
-      end
-
+      
     end
   end
 end

data/lib/apartment/version.rb

@@ -1,3 +1,3 @@
 module Apartment
-  VERSION = "0.13.0.1"
+  VERSION = "0.13.1"
 end

data/spec/adapters/postgresql_adapter_spec.rb

@@ -2,76 +2,67 @@ require 'spec_helper'
 require 'apartment/adapters/postgresql_adapter'   # specific adapters get dynamically loaded based on adapter name, so we must manually require here
 
 describe Apartment::Adapters::PostgresqlAdapter do
-
+  
   before do
     ActiveRecord::Base.establish_connection Apartment::Test.config['connections']['postgresql']
     @schema_search_path = ActiveRecord::Base.connection.schema_search_path
   end
-
+  
   after do
     ActiveRecord::Base.clear_all_connections!
   end
-
+  
   context "using schemas" do
-
+    
     let(:schema){ 'first_db_schema' }
     let(:schema2){ 'another_db_schema' }
     let(:database_names){ ActiveRecord::Base.connection.execute("SELECT nspname FROM pg_namespace;").collect{|row| row['nspname']} }
-
+    
     subject{ Apartment::Database.postgresql_adapter Apartment::Test.config['connections']['postgresql'].symbolize_keys }
-
+  
     before do
       Apartment.use_postgres_schemas = true
       subject.create(schema)
       subject.create(schema2)
     end
-
+  
     after do
       # sometimes we manually drop these schemas in testing, dont' care if we can't drop hence rescue
-      subject.drop(schema) rescue true
+      subject.drop(schema) rescue true 
       subject.drop(schema2) rescue true
     end
-
+    
     describe "#create" do
-
+      
       it "should create the new schema" do
         database_names.should include(schema)
       end
-
+    
       it "should load schema.rb to new schema" do
         ActiveRecord::Base.connection.schema_search_path = schema
         ActiveRecord::Base.connection.tables.should include('companies')
       end
-
-      it "should not load schema.rb if load_schema is false" do
-        Apartment.load_schema = false
-        subject.create("schemax") do
-          ActiveRecord::Base.connection.tables.should_not include('companies')
-        end
-        # Cleanup
-        subject.drop("schemax")
-      end
-
+    
       it "should reset connection when finished" do
         ActiveRecord::Base.connection.schema_search_path.should_not == schema
       end
-
+      
       it "should yield to block if passed" do
-        Apartment::Test.migrate   # ensure we have latest schema in the public
+        Apartment::Test.migrate   # ensure we have latest schema in the public 
         subject.drop(schema2) # so we don't get errors on creation
-
+        
         @count = 0  # set our variable so its visible in and outside of blocks
-
+        
         subject.create(schema2) do
           @count = User.count
           ActiveRecord::Base.connection.schema_search_path.should == schema2
           User.create
         end
-
+        
         subject.process(schema2){ User.count.should == @count + 1 }
       end
     end
-
+    
     describe "#drop" do
 
       it "should delete the database" do
@@ -87,31 +78,31 @@ describe Apartment::Adapters::PostgresqlAdapter do
         }.to raise_error(Apartment::SchemaNotFound)
       end
     end
-
-
+    
+    
     describe "#process" do
       it "should connect" do
         subject.process(schema) do
           ActiveRecord::Base.connection.schema_search_path.should == schema
         end
       end
-
+      
       it "should reset" do
         subject.process(schema)
         ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
       end
-
+      
       # We're often finding when using Apartment in tests, the `current_database` (ie the previously attached to schema)
       # gets dropped, but process will try to return to that schema in a test.  We should just reset if it doesnt exist
       it "should not throw exception if current_database (schema) is no longer accessible" do
         subject.switch(schema2)
-
+        
         expect {
           subject.process(schema){ subject.drop(schema2) }
         }.to_not raise_error(Apartment::SchemaNotFound)
       end
     end
-
+    
     describe "#reset" do
       it "should reset connection" do
         subject.switch(schema)
@@ -119,28 +110,28 @@ describe Apartment::Adapters::PostgresqlAdapter do
         ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
       end
     end
-
+    
     describe "#switch" do
       it "should connect to new schema" do
         subject.switch(schema)
         ActiveRecord::Base.connection.schema_search_path.should == schema
       end
-
+      
       it "should reset connection if database is nil" do
         subject.switch
         ActiveRecord::Base.connection.schema_search_path.should == @schema_search_path
       end
     end
-
+    
     describe "#current_database" do
       it "should return the current schema name" do
         subject.switch(schema)
         subject.current_database.should == schema
       end
     end
-
+    
   end
-
+  
   context "using databases" do
     # TODO
   end