apartment 0.23.2 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5d4ac99414fa53017af053bc0c2ad582a92a194
-  data.tar.gz: 822538642d3344ed4dd46839f0a003a5f67e2900
+  metadata.gz: bc20eef867490ea70d61bd13cf152a659cfb0fa4
+  data.tar.gz: b1110bf18327723c487d0cb1efe82f85a7d7bfc6
 SHA512:
-  metadata.gz: a2e83c0bfe6cb7e381d2232aea4bd77020df2fac80deda6ee3754fad54de3acc4d03cf30a38ec5092e0b99bbb25ac0888ac6c8d7a8884dfefb24f12342e243d8
-  data.tar.gz: b6f54b75336cdd0e6f565d0831240f6526aabd18882e770d924a1e4b0f5a7e222a8d65c76e9878c445ac9154c6241ea5ddddf9fcd497906e46e6949af3eb6458
+  metadata.gz: cc1d19df9b94a6703c1d2a88b93c628bdb809ae729e104afa8550e51dfed3da2dd958292936f971e5c22e07e58d6a032e9f0300a2a1a65856e9986e8d2d44937
+  data.tar.gz: 3bd127557fdd6743d6886ebf3ea4c720a5ebd6deff4623f519078bef5cf55e9db2f528e13458bb38cecde6d36762a1178ec2fa3e61c111b05cc74f3614e27ebb

data/HISTORY.md

@@ -1,4 +1,15 @@
-# 0 23.2
+# 0.24
+  * February 21, 2014 (In honour of the Women's Gold Medal in Hockey at Sochi)
+
+  - [BREAKING CHANGE] `apartment:migrate` task no longer depends on `db:migrate`
+    - Instead, you can `require 'apartment/tasks/enhancements'` in your Apartment initializer
+    - This will enhance `rake db:migrate` to also run `apartment:migrate`
+    - You can now forget about ever running `apartment:migrate` again
+  - Numerous deprecations for things referencing the word 'database'
+    - This is an ongoing effort to completely replace 'database' with 'tenant' as a better abstraction
+    - Note the obvious `Apartment::Database` still exists but will hopefully become `Apartment::Tenant` soon
+
+# 0.23.2
   * January 9, 2014
 
   - Increased visibility of #parse_database_name warning

data/README.md

@@ -2,7 +2,7 @@
 [![Code Climate](https://codeclimate.com/github/influitive/apartment.png)](https://codeclimate.com/github/influitive/apartment)
 [![Build Status](https://secure.travis-ci.org/influitive/apartment.png?branch=development)](http://travis-ci.org/influitive/apartment)
 
-*Multitenancy for Rails 3 and ActiveRecord*
+*Multitenancy for Rails and ActiveRecord*
 
 Apartment provides tools to help you deal with multiple databases in your Rails
 application. If you need to have certain data sequestered based on account or company,
@@ -11,7 +11,7 @@ but still allow some data to exist in a common database, Apartment can help.
 
 ## Installation
 
-### Rails 3
+### Rails
 
 Add the following to your Gemfile:
 
@@ -164,7 +164,7 @@ end
 
 ### Excluding models
 
-If you have some models that should always access the 'root' database, you can specify this by configuring Apartment using `Apartment.configure`.  This will yield a config object for you.  You can set excluded models like so:
+If you have some models that should always access the 'public' database, you can specify this by configuring Apartment using `Apartment.configure`.  This will yield a config object for you.  You can set excluded models like so:
 
 ```ruby
 config.excluded_models = ["User", "Company"]        # these models will not be multi-tenanted, but remain in the global (public) namespace
@@ -172,7 +172,10 @@ config.excluded_models = ["User", "Company"]        # these models will not be m
 
 Note that a string representation of the model name is now the standard so that models are properly constantized when reloaded in development
 
-Rails will always access the 'root' database when accessing these models,  but note that tables will be created in all schemas.  This may not be ideal, but its done this way because otherwise rails wouldn't be able to properly generate the schema.rb file.
+Rails will always access the 'public' database when accessing these models,  but note that tables will be created in all schemas.  This may not be ideal, but its done this way because otherwise rails wouldn't be able to properly generate the schema.rb file.
+
+> **NOTE - Many-To-Many Excluded Models:**
+> Since model exclusions must come from referencing a real ActiveRecord model, `has_and_belongs_to_many` is NOT supported. In order to achieve a many-to-many relationship for excluded models, you MUST use `has_many :through`. This way you can reference the join model in the excluded models configuration.
 
 ### Postgresql Schemas
 
@@ -221,7 +224,7 @@ schema_search_path: "public,hstore"
 This would be for a config with `default_schema` set to `public` and `persistent_schemas` set to `['hstore']`
 
 Another way that we've successfully configured hstore for our applications is to add it into the
-postgresql template1 database so that every db that gets created has it by default.
+postgresql template1 database so that every tenant that gets created has it by default.
 
 You can do so using a command like so
 
@@ -239,26 +242,26 @@ Happy to accept PR's on the matter.
 
 In order to migrate all of your databases (or posgresql schemas) you need to provide a list
 of dbs to Apartment.  You can make this dynamic by providing a Proc object to be called on migrations.
-This object should yield an array of string representing each database name.  Example:
+This object should yield an array of string representing each tenant name.  Example:
 
 ```ruby
-# Dynamically get database names to migrate
-config.database_names = lambda{ Customer.pluck(:database_name) }
+# Dynamically get tenant names to migrate
+config.tenant_names = lambda{ Customer.pluck(:tenant_name) }
 
-# Use a static list of database names for migrate
-config.database_names = ['db1', 'db2']
+# Use a static list of tenant names for migrate
+config.tenant_names = ['tenant1', 'tenant2']
 ```
 
 You can then migrate your databases using the rake task:
 
     rake apartment:migrate
 
-This basically invokes `Apartment::Database.migrate(#{db_name})` for each database name supplied
-from `Apartment.database_names`
+This basically invokes `Apartment::Database.migrate(#{tenant_name})` for each tenant name supplied
+from `Apartment.tenant_names`
 
 ### Handling Environments
 
-By default, when not using postgresql schemas, Apartment will prepend the environment to the database name
+By default, when not using postgresql schemas, Apartment will prepend the environment to the tenant name
 to ensure there is no conflict between your environments.  This is mainly for the benefit of your development
 and test environments.  If you wish to turn this option off in production, you could do something like:
 

data/Rakefile

@@ -13,13 +13,18 @@ RSpec::Core::RakeTask.new(:spec => %w{ db:copy_credentials db:test:prepare }) do
 end
 
 namespace :spec do
-
   [:tasks, :unit, :adapters, :integration].each do |type|
     RSpec::Core::RakeTask.new(type => :spec) do |spec|
       spec.pattern = "spec/#{type}/**/*_spec.rb"
     end
   end
+end
 
+task :console do
+  require 'pry'
+  require 'apartment'
+  ARGV.clear
+  Pry.start
 end
 
 task :default => :spec

data/TODO.md

@@ -15,8 +15,7 @@
     It would be nice if a user can 'register' an adapter such that it would automatically be tested (nice to have). Otherwise one could just use
     a shared behaviour to run through all of this.
 
-    Then, I'd like to see all of the implementation specific tests just in their own test file for each adapter (ie the postgresql schema adapter
-    checks a lot of things with `schema_search_path`)
+    Then, I'd like to see all of the implementation specific tests just in their own test file for each adapter (ie the postgresql schema adapter checks a lot of things with `schema_search_path`)
 
     This should ensure that going forward nothing breaks, and we should *ideally* be able to randomize the test order
 
@@ -24,24 +23,20 @@
     think about Tenants. I proprose that we deprecate the `Apartment::Database` constant in favour of `Apartment::Tenant` for a nicer abstraction. See
     http://myronmars.to/n/dev-blog/2011/09/deprecating-constants-and-classes-in-ruby for ideas on how to achieve this.
 
-4.  Apartment::Database.process should be deprecated in favour of just passing an optional block to `switch`
+4.  Apartment::Database.process should be deprecated in favour of just passing a block to `switch`
+5.  Apartment::Database.switch should be renamed to switch! to indicate that using it on its own has side effects
 
-5.  Migrations right now can be a bit of a pain. Apartment currently migrates a single tenant completely up to date, then goes onto the next. If one of these
+6.  Migrations right now can be a bit of a pain. Apartment currently migrates a single tenant completely up to date, then goes onto the next. If one of these
     migrations fails on a tenant, the previous one does NOT get reverted and leaves you in an awkward state. Ideally we'd want to wrap all of the migrations in
     a transaction so if one fails, the whole thing reverts. Once we can ensure an all-or-nothing approach to migrations, we can optimize the migration strategy
-    to not even iterate over the tenants if there are no migrations to run on public. I also thought id would be nice to provide an optional file to require in one's
-    Rakefile such that it would override `db:migrate` to do `apartment:migrate`. That way people don't have to remember to use a different task and there's no confusion.
+    to not even iterate over the tenants if there are no migrations to run on public.
 
-6.  Apartment has be come one of the most popular/robust Multi-tenant gems for Rails, but it still doesn't work for everyone's use case. It's fairly limited
-    in implementation to either schema based (ie postgresql schemas) or connection based. I'd like to abstract out these implementation details such that one
-    could write a pluggable strategy for Apartment and choose it based on a config selection (something like `config.strategy = :schema`). The next implementation
-    I'd like to see is a scoped based approach that uses a `tenant_id` scoping on all records for multi-tenancy. This is probably the most popular multi-tenant approach
-    and is db independent and really the simplest mechanism for a type of multi-tenancy.
+7.  Apartment has be come one of the most popular/robust Multi-tenant gems for Rails, but it still doesn't work for everyone's use case. It's fairly limited in implementation to either schema based (ie postgresql schemas) or connection based. I'd like to abstract out these implementation details such that one could write a pluggable strategy for Apartment and choose it based on a config selection (something like `config.strategy = :schema`). The next implementation I'd like to see is a scoped based approach that uses a `tenant_id` scoping on all records for multi-tenancy. This is probably the most popular multi-tenant approach and is db independent and really the simplest mechanism for a type of multi-tenancy.
 
-7.  Right now excluded tables still live in all tenanted environments. This is basically because it doesn't matter if they're there, we always query from the public.
+8.  Right now excluded tables still live in all tenanted environments. This is basically because it doesn't matter if they're there, we always query from the public.
     It's a bit of an annoyance though and confuses lots of people. I'd love to see only tenanted tables in the tenants and only excluded tables in the public tenant.
     This will be hard because Rails uses public to generate schema.rb. One idea is to have an `excluded` schema that holds all the excluded models and the public can
     maintain everything.
 
-8.  This one is pretty lofty, but I'd also like to abstract out the fact that Apartment uses ActiveRecord. With the new DataMapper coming out soon and other popular
-    DBMS's (ie. mongo, couch etc...), it'd be nice if Apartment could be the de-facto interface for multi-tenancy on these systems.
+9.  This one is pretty lofty, but I'd also like to abstract out the fact that Apartment uses ActiveRecord. With the new DataMapper coming out soon and other popular
+    DBMS's (ie. mongo, couch etc...), it'd be nice if Apartment could be the de-facto interface for multi-tenancy on these systems.

data/lib/apartment.rb

@@ -11,7 +11,7 @@ module Apartment
     extend Forwardable
 
     ACCESSOR_METHODS  = [:use_schemas, :seed_after_create, :prepend_environment, :append_environment]
-    WRITER_METHODS    = [:database_names, :database_schema_file, :excluded_models, :default_schema, :persistent_schemas, :connection_class]
+    WRITER_METHODS    = [:tenant_names, :database_schema_file, :excluded_models, :default_schema, :persistent_schemas, :connection_class, :tld_length]
 
     attr_accessor(*ACCESSOR_METHODS)
     attr_writer(*WRITER_METHODS)
@@ -24,8 +24,8 @@ module Apartment
     end
 
     # Be careful not to use `return` here so both Proc and lambda can be used without breaking
-    def database_names
-      @database_names.respond_to?(:call) ? @database_names.call : @database_names
+    def tenant_names
+      @tenant_names.respond_to?(:call) ? @tenant_names.call : @tenant_names
     end
 
     # Default to empty array
@@ -51,11 +51,25 @@ module Apartment
       @database_schema_file = Rails.root.join('db', 'schema.rb')
     end
 
+    def tld_length
+      @tld_length || 1
+    end
+
     # Reset all the config for Apartment
     def reset
       (ACCESSOR_METHODS + WRITER_METHODS).each{|method| remove_instance_variable(:"@#{method}") if instance_variable_defined?(:"@#{method}") }
     end
 
+    def database_names
+      warn "[Deprecation Warning] `database_names` is now deprecated, please use `tenant_names`"
+      tenant_names
+    end
+
+    def database_names=(names)
+      warn "[Deprecation Warning] `database_names=` is now deprecated, please use `tenant_names=`"
+      self.tenant_names=(names)
+    end
+
     def use_postgres_schemas
       warn "[Deprecation Warning] `use_postgresql_schemas` is now deprecated, please use `use_schemas`"
       use_schemas

data/lib/apartment/adapters/abstract_adapter.rb

@@ -9,14 +9,14 @@ module Apartment
         @config = config
       end
 
-      #   Create a new database, import schema, seed if appropriate
+      #   Create a new tenant, import schema, seed if appropriate
       #
-      #   @param {String} database Database name
+      #   @param {String} tenant Tenant name
       #
-      def create(database)
-        create_tenant(database)
+      def create(tenant)
+        create_tenant(tenant)
 
-        process(database) do
+        process(tenant) do
           import_database_schema
 
           # Seed data if appropriate
@@ -26,43 +26,52 @@ module Apartment
         end
       end
 
-      #   Get the current database name
+      #   Get the current tenant name
       #
-      #   @return {String} current database name
+      #   @return {String} current tenant name
       #
       def current_database
+        warn "[Deprecation Warning] `current_database` is now deprecated, please use `current_tenant`"
+        current_tenant
+      end
+
+      #   Get the current tenant name
+      #
+      #   @return {String} current tenant name
+      #
+      def current_tenant
         Apartment.connection.current_database
       end
 
       #   Note alias_method here doesn't work with inheritence apparently ??
       #
       def current
-        current_database
+        current_tenant
       end
 
-      #   Drop the database
+      #   Drop the tenant
       #
-      #   @param {String} database Database name
+      #   @param {String} tenant Database name
       #
-      def drop(database)
+      def drop(tenant)
         # Apartment.connection.drop_database   note that drop_database will not throw an exception, so manually execute
-        Apartment.connection.execute("DROP DATABASE #{environmentify(database)}" )
+        Apartment.connection.execute("DROP DATABASE #{environmentify(tenant)}" )
 
       rescue *rescuable_exceptions
-        raise DatabaseNotFound, "The database #{environmentify(database)} cannot be found"
+        raise DatabaseNotFound, "The tenant #{environmentify(tenant)} cannot be found"
       end
 
-      #   Connect to db, do your biz, switch back to previous db
+      #   Connect to tenant, do your biz, switch back to previous tenant
       #
-      #   @param {String?} database Database or schema to connect to
+      #   @param {String?} tenant Database or schema to connect to
       #
-      def process(database = nil)
-        current_db = current_database
-        switch(database)
+      def process(tenant = nil)
+        previous_tenant = current_tenant
+        switch(tenant)
         yield if block_given?
 
       ensure
-        switch(current_db) rescue reset
+        switch(previous_tenant) rescue reset
       end
 
       #   Establish a new connection for each specific excluded model
@@ -74,7 +83,7 @@ module Apartment
         end
       end
 
-      #   Reset the database connection to the default
+      #   Reset the tenant connection to the default
       #
       def reset
         Apartment.establish_connection @config
@@ -82,13 +91,13 @@ module Apartment
 
       #   Switch to new connection (or schema if appopriate)
       #
-      #   @param {String} database Database name
+      #   @param {String} tenant Database name
       #
-      def switch(database = nil)
+      def switch(tenant = nil)
         # Just connect to default db and return
-        return reset if database.nil?
+        return reset if tenant.nil?
 
-        connect_to_new(database).tap do
+        connect_to_new(tenant).tap do
           ActiveRecord::Base.connection.clear_query_cache
         end
       end
@@ -102,45 +111,45 @@ module Apartment
 
     protected
 
-      #   Create the database
+      #   Create the tenant
       #
-      #   @param {String} database Database name
+      #   @param {String} tenant Database name
       #
-      def create_tenant(database)
-        Apartment.connection.create_database( environmentify(database) )
+      def create_tenant(tenant)
+        Apartment.connection.create_database( environmentify(tenant) )
 
       rescue *rescuable_exceptions
-        raise DatabaseExists, "The database #{environmentify(database)} already exists."
+        raise DatabaseExists, "The tenant #{environmentify(tenant)} already exists."
       end
 
-      #   Connect to new database
+      #   Connect to new tenant
       #
-      #   @param {String} database Database name
+      #   @param {String} tenant Database name
       #
-      def connect_to_new(database)
-        Apartment.establish_connection multi_tenantify(database)
+      def connect_to_new(tenant)
+        Apartment.establish_connection multi_tenantify(tenant)
         Apartment.connection.active?   # call active? to manually check if this connection is valid
 
       rescue *rescuable_exceptions
-        raise DatabaseNotFound, "The database #{environmentify(database)} cannot be found."
+        raise DatabaseNotFound, "The tenant #{environmentify(tenant)} cannot be found."
       end
 
       #   Prepend the environment if configured and the environment isn't already there
       #
-      #   @param {String} database Database name
-      #   @return {String} database name with Rails environment *optionally* prepended
+      #   @param {String} tenant Database name
+      #   @return {String} tenant name with Rails environment *optionally* prepended
       #
-      def environmentify(database)
-        unless database.include?(Rails.env)
+      def environmentify(tenant)
+        unless tenant.include?(Rails.env)
           if Apartment.prepend_environment
-            "#{Rails.env}_#{database}"
+            "#{Rails.env}_#{tenant}"
           elsif Apartment.append_environment
-            "#{database}_#{Rails.env}"
+            "#{tenant}_#{Rails.env}"
           else
-            database
+            tenant
           end
         else
-          database
+          tenant
         end
       end
 
@@ -154,9 +163,9 @@ module Apartment
 
       #   Return a new config that is multi-tenanted
       #
-      def multi_tenantify(database)
+      def multi_tenantify(tenant)
         @config.clone.tap do |config|
-          config[:database] = environmentify(database)
+          config[:database] = environmentify(tenant)
         end
       end
 

data/lib/apartment/adapters/jdbc_postgresql_adapter.rb

@@ -17,20 +17,20 @@ module Apartment
 
     protected
 
-      def create_tenant(database)
+      def create_tenant(tenant)
         # There is a bug in activerecord-jdbcpostgresql-adapter (1.2.5) that will cause
         # an exception if no options are passed into the create_database call.
-        Apartment.connection.create_database(environmentify(database), { :thisisahack => '' })
+        Apartment.connection.create_database(environmentify(tenant), { :thisisahack => '' })
 
       rescue *rescuable_exceptions
-        raise DatabaseExists, "The database #{environmentify(database)} already exists."
+        raise DatabaseExists, "The tenant #{environmentify(tenant)} already exists."
       end
 
       #   Return a new config that is multi-tenanted
       #
-      def multi_tenantify(database)
+      def multi_tenantify(tenant)
         @config.clone.tap do |config|
-          config[:url] = "#{config[:url].gsub(/(\S+)\/.+$/, '\1')}/#{environmentify(database)}"
+          config[:url] = "#{config[:url].gsub(/(\S+)\/.+$/, '\1')}/#{environmentify(tenant)}"
         end
       end
 
@@ -46,11 +46,11 @@ module Apartment
 
       #   Set schema search path to new schema
       #
-      def connect_to_new(database = nil)
-        return reset if database.nil?
-        raise ActiveRecord::StatementInvalid.new("Could not find schema #{database}") unless Apartment.connection.all_schemas.include? database.to_s
+      def connect_to_new(tenant = nil)
+        return reset if tenant.nil?
+        raise ActiveRecord::StatementInvalid.new("Could not find schema #{tenant}") unless Apartment.connection.all_schemas.include? tenant.to_s
 
-        @current_database = database.to_s
+        @current_tenant = tenant.to_s
         Apartment.connection.schema_search_path = full_search_path
 
       rescue ActiveRecord::StatementInvalid, ActiveRecord::JDBCError