acts_as_tenant 0.4.2 → 0.5.1

data/lib/acts_as_tenant/model_extensions.rb

@@ -1,109 +1,34 @@
 module ActsAsTenant
-  @@tenant_klass = nil
-  @@models_with_global_records = []
-
-  def self.set_tenant_klass(klass)
-    @@tenant_klass = klass
-  end
-
-  def self.tenant_klass
-    @@tenant_klass
-  end
-
-  def self.models_with_global_records
-    @@models_with_global_records
-  end
-
-  def self.add_global_record_model model
-    @@models_with_global_records.push(model)
-  end
-
-  def self.fkey
-    "#{@@tenant_klass.to_s}_id"
-  end
-
-  def self.current_tenant=(tenant)
-    RequestStore.store[:current_tenant] = tenant
-  end
-
-  def self.current_tenant
-    RequestStore.store[:current_tenant] || self.default_tenant
-  end
-
-  def self.unscoped=(unscoped)
-    RequestStore.store[:acts_as_tenant_unscoped] = unscoped
-  end
-
-  def self.unscoped
-    RequestStore.store[:acts_as_tenant_unscoped]
-  end
-
-  def self.unscoped?
-    !!unscoped
-  end
-
-  class << self
-    attr_accessor :default_tenant
-  end
-
-  def self.with_tenant(tenant, &block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
-
-    old_tenant = self.current_tenant
-    self.current_tenant = tenant
-    value = block.call
-    return value
-
-  ensure
-    self.current_tenant = old_tenant
-  end
-
-  def self.without_tenant(&block)
-    if block.nil?
-      raise ArgumentError, "block required"
-    end
-
-    old_tenant = current_tenant
-    old_unscoped = unscoped
-
-    self.current_tenant = nil
-    self.unscoped = true
-    value = block.call
-    return value
-
-  ensure
-    self.current_tenant = old_tenant
-    self.unscoped = old_unscoped
-  end
-
   module ModelExtensions
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    extend ActiveSupport::Concern
 
-    module ClassMethods
-      def acts_as_tenant(tenant = :account, options = {})
+    class_methods do
+      def acts_as_tenant(tenant = :account, **options)
         ActsAsTenant.set_tenant_klass(tenant)
 
         ActsAsTenant.add_global_record_model(self) if options[:has_global_records]
 
         # Create the association
-        valid_options = options.slice(:foreign_key, :class_name, :inverse_of)
+        valid_options = options.slice(:foreign_key, :class_name, :inverse_of, :optional, :primary_key, :counter_cache)
         fkey = valid_options[:foreign_key] || ActsAsTenant.fkey
-        belongs_to tenant, valid_options
+        pkey = valid_options[:primary_key] || ActsAsTenant.pkey
+        polymorphic_type = valid_options[:foreign_type] || ActsAsTenant.polymorphic_type
+        belongs_to tenant, **valid_options
 
         default_scope lambda {
           if ActsAsTenant.configuration.require_tenant && ActsAsTenant.current_tenant.nil? && !ActsAsTenant.unscoped?
             raise ActsAsTenant::Errors::NoTenantSet
           end
+
           if ActsAsTenant.current_tenant
-            keys = [ActsAsTenant.current_tenant.id]
+            keys = [ActsAsTenant.current_tenant.send(pkey)].compact
             keys.push(nil) if options[:has_global_records]
-            where(fkey.to_sym => keys)
+
+            query_criteria = {fkey.to_sym => keys}
+            query_criteria[polymorphic_type.to_sym] = ActsAsTenant.current_tenant.class.to_s if options[:polymorphic]
+            where(query_criteria)
           else
-            Rails::VERSION::MAJOR < 4 ? scoped : all
+            all
           end
         }
 
@@ -111,26 +36,30 @@ module ActsAsTenant
         # - new instances should have the tenant set
         # - validate that associations belong to the tenant, currently only for belongs_to
         #
-        before_validation Proc.new {|m|
+        before_validation proc { |m|
           if ActsAsTenant.current_tenant
-            m.send "#{fkey}=".to_sym, ActsAsTenant.current_tenant.id
+            if options[:polymorphic]
+              m.send("#{fkey}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(fkey.to_s).nil?
+              m.send("#{polymorphic_type}=".to_sym, ActsAsTenant.current_tenant.class.to_s) if m.send(polymorphic_type.to_s).nil?
+            else
+              m.send "#{fkey}=".to_sym, ActsAsTenant.current_tenant.send(pkey)
+            end
           end
-        }, :on => :create
+        }, on: :create
 
-        polymorphic_foreign_keys = reflect_on_all_associations(:belongs_to).select do |a|
+        polymorphic_foreign_keys = reflect_on_all_associations(:belongs_to).select { |a|
           a.options[:polymorphic]
-        end.map { |a| a.foreign_key }
+        }.map { |a| a.foreign_key }
 
         reflect_on_all_associations(:belongs_to).each do |a|
           unless a == reflect_on_association(tenant) || polymorphic_foreign_keys.include?(a.foreign_key)
-            association_class =  a.options[:class_name].nil? ? a.name.to_s.classify.constantize : a.options[:class_name].constantize
             validates_each a.foreign_key.to_sym do |record, attr, value|
-              primary_key = if association_class.respond_to?(:primary_key)
-                              association_class.primary_key
-                            else
-                              a.primary_key
-                            end.to_sym
-              record.errors.add attr, "association is invalid [ActsAsTenant]" unless value.nil? || association_class.where(primary_key => value).any?
+              primary_key = if a.respond_to?(:active_record_primary_key)
+                a.active_record_primary_key
+              else
+                a.primary_key
+              end.to_sym
+              record.errors.add attr, "association is invalid [ActsAsTenant]" unless value.nil? || a.klass.where(primary_key => value).any?
             end
           end
         end
@@ -139,27 +68,19 @@ module ActsAsTenant
         # - Rewrite the accessors to make tenant immutable
         # - Add an override to prevent unnecessary db hits
         # - Add a helper method to verify if a model has been scoped by AaT
-        to_include = Module.new do
+        to_include = Module.new {
           define_method "#{fkey}=" do |integer|
-            write_attribute("#{fkey}", integer)
+            write_attribute(fkey.to_s, integer)
             raise ActsAsTenant::Errors::TenantIsImmutable if send("#{fkey}_changed?") && persisted? && !send("#{fkey}_was").nil?
             integer
           end
 
-          define_method "#{ActsAsTenant.tenant_klass.to_s}=" do |model|
+          define_method "#{ActsAsTenant.tenant_klass}=" do |model|
             super(model)
             raise ActsAsTenant::Errors::TenantIsImmutable if send("#{fkey}_changed?") && persisted? && !send("#{fkey}_was").nil?
             model
           end
-
-          define_method "#{ActsAsTenant.tenant_klass.to_s}" do
-            if !ActsAsTenant.current_tenant.nil? && send(fkey) == ActsAsTenant.current_tenant.id
-              return ActsAsTenant.current_tenant
-            else
-              super()
-            end
-          end
-        end
+        }
         include to_include
 
         class << self
@@ -169,36 +90,38 @@ module ActsAsTenant
         end
       end
 
-      def validates_uniqueness_to_tenant(fields, args ={})
+      def validates_uniqueness_to_tenant(fields, args = {})
         raise ActsAsTenant::Errors::ModelNotScopedByTenant unless respond_to?(:scoped_by_tenant?)
+
         fkey = reflect_on_association(ActsAsTenant.tenant_klass).foreign_key
-        #tenant_id = lambda { "#{ActsAsTenant.fkey}"}.call
-        if args[:scope]
-          args[:scope] = Array(args[:scope]) << fkey
+
+        validation_args = args.clone
+        validation_args[:scope] = if args[:scope]
+          Array(args[:scope]) << fkey
         else
-          args[:scope] = fkey
+          fkey
         end
 
-        validates_uniqueness_of(fields, args)
+        # validating within tenant scope
+        validates_uniqueness_of(fields, validation_args)
 
         if ActsAsTenant.models_with_global_records.include?(self)
-          validate do |instance|
-            Array(fields).each do |field|
-              if instance.new_record?
-                unless self.class.where(fkey.to_sym => [nil, instance[fkey]],
-                                        field.to_sym => instance[field]).empty?
-                  errors.add(field, 'has already been taken') 
-                end
-              else
-                unless self.class.where(fkey.to_sym => [nil, instance[fkey]],
-                                        field.to_sym => instance[field])
-                                 .where.not(:id => instance.id).empty?
-                  errors.add(field, 'has already been taken') 
-                end
-
-              end
-            end
-          end
+          arg_if = args.delete(:if)
+          arg_condition = args.delete(:conditions)
+
+          # if tenant is not set (instance is global) - validating globally
+          global_validation_args = args.merge(
+            if: ->(instance) { instance[fkey].blank? && (arg_if.blank? || arg_if.call(instance)) }
+          )
+          validates_uniqueness_of(fields, global_validation_args)
+
+          # if tenant is set (instance is not global) and records can be global - validating within records with blank tenant
+          blank_tenant_validation_args = args.merge({
+            conditions: -> { arg_condition.blank? ? where(fkey => nil) : arg_condition.call.where(fkey => nil) },
+            if: ->(instance) { instance[fkey].present? && (arg_if.blank? || arg_if.call(instance)) }
+          })
+
+          validates_uniqueness_of(fields, blank_tenant_validation_args)
         end
       end
     end

data/lib/acts_as_tenant/sidekiq.rb

@@ -2,11 +2,13 @@ module ActsAsTenant::Sidekiq
   # Get the current tenant and store in the message to be sent to Sidekiq.
   class Client
     def call(worker_class, msg, queue, redis_pool)
-      msg['acts_as_tenant'] ||=
-        {
-            'class' => ActsAsTenant.current_tenant.class.name,
-            'id' => ActsAsTenant.current_tenant.id
-        } if ActsAsTenant.current_tenant.present?
+      if ActsAsTenant.current_tenant.present?
+        msg["acts_as_tenant"] ||=
+          {
+            "class" => ActsAsTenant.current_tenant.class.name,
+            "id" => ActsAsTenant.current_tenant.id
+          }
+      end
 
       yield
     end
@@ -15,8 +17,8 @@ module ActsAsTenant::Sidekiq
   # Pull the tenant out and run the current thread with it.
   class Server
     def call(worker_class, msg, queue)
-      if msg.has_key?('acts_as_tenant')
-        account = msg['acts_as_tenant']['class'].constantize.find msg['acts_as_tenant']['id']
+      if msg.has_key?("acts_as_tenant")
+        account = msg["acts_as_tenant"]["class"].constantize.find msg["acts_as_tenant"]["id"]
         ActsAsTenant.with_tenant account do
           yield
         end
@@ -38,6 +40,12 @@ Sidekiq.configure_server do |config|
     chain.add ActsAsTenant::Sidekiq::Client
   end
   config.server_middleware do |chain|
-    chain.insert_before Sidekiq::Middleware::Server::RetryJobs, ActsAsTenant::Sidekiq::Server
+    if defined?(Sidekiq::Middleware::Server::RetryJobs)
+      chain.insert_before Sidekiq::Middleware::Server::RetryJobs, ActsAsTenant::Sidekiq::Server
+    elsif defined?(Sidekiq::Batch::Server)
+      chain.insert_before Sidekiq::Batch::Server, ActsAsTenant::Sidekiq::Server
+    else
+      chain.add ActsAsTenant::Sidekiq::Server
+    end
   end
 end

data/lib/acts_as_tenant/tenant_helper.rb

@@ -0,0 +1,7 @@
+module ActsAsTenant
+  module TenantHelper
+    def current_tenant
+      ActsAsTenant.current_tenant
+    end
+  end
+end

data/lib/acts_as_tenant/test_tenant_middleware.rb

@@ -0,0 +1,15 @@
+module ActsAsTenant
+  class TestTenantMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      previously_set_test_tenant = ActsAsTenant.test_tenant
+      ActsAsTenant.test_tenant = nil
+      @app.call(env)
+    ensure
+      ActsAsTenant.test_tenant = previously_set_test_tenant
+    end
+  end
+end

data/lib/acts_as_tenant/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTenant
-  VERSION = "0.4.2"
+  VERSION = "0.5.1"
 end

data/lib/acts_as_tenant.rb

@@ -1,27 +1,125 @@
 require "request_store"
 
-#$LOAD_PATH.unshift(File.dirname(__FILE__))
-
 require "acts_as_tenant/version"
 require "acts_as_tenant/errors"
-require "acts_as_tenant/configuration"
-require "acts_as_tenant/controller_extensions"
-require "acts_as_tenant/model_extensions"
 
-#$LOAD_PATH.shift
+module ActsAsTenant
+  autoload :Configuration, "acts_as_tenant/configuration"
+  autoload :ControllerExtensions, "acts_as_tenant/controller_extensions"
+  autoload :ModelExtensions, "acts_as_tenant/model_extensions"
+  autoload :TenantHelper, "acts_as_tenant/tenant_helper"
+
+  @@configuration = nil
+  @@tenant_klass = nil
+  @@models_with_global_records = []
+
+  class << self
+    attr_accessor :test_tenant
+    attr_writer :default_tenant
+  end
+
+  def self.configure
+    @@configuration = Configuration.new
+    yield configuration if block_given?
+    configuration
+  end
+
+  def self.configuration
+    @@configuration || configure
+  end
+
+  def self.set_tenant_klass(klass)
+    @@tenant_klass = klass
+  end
+
+  def self.tenant_klass
+    @@tenant_klass
+  end
+
+  def self.models_with_global_records
+    @@models_with_global_records
+  end
+
+  def self.add_global_record_model model
+    @@models_with_global_records.push(model)
+  end
+
+  def self.fkey
+    "#{@@tenant_klass}_id"
+  end
+
+  def self.pkey
+    ActsAsTenant.configuration.pkey
+  end
 
-if defined?(ActiveRecord::Base)
-  ActiveRecord::Base.send(:include, ActsAsTenant::ModelExtensions)
+  def self.polymorphic_type
+    "#{@@tenant_klass}_type"
+  end
+
+  def self.current_tenant=(tenant)
+    RequestStore.store[:current_tenant] = tenant
+  end
+
+  def self.current_tenant
+    RequestStore.store[:current_tenant] || test_tenant || default_tenant
+  end
+
+  def self.unscoped=(unscoped)
+    RequestStore.store[:acts_as_tenant_unscoped] = unscoped
+  end
+
+  def self.unscoped
+    RequestStore.store[:acts_as_tenant_unscoped]
+  end
+
+  def self.unscoped?
+    !!unscoped
+  end
+
+  def self.default_tenant
+    @default_tenant unless unscoped
+  end
+
+  def self.with_tenant(tenant, &block)
+    if block.nil?
+      raise ArgumentError, "block required"
+    end
+
+    old_tenant = current_tenant
+    self.current_tenant = tenant
+    value = block.call
+    value
+  ensure
+    self.current_tenant = old_tenant
+  end
+
+  def self.without_tenant(&block)
+    if block.nil?
+      raise ArgumentError, "block required"
+    end
+
+    old_tenant = current_tenant
+    old_unscoped = unscoped
+
+    self.current_tenant = nil
+    self.unscoped = true
+    value = block.call
+    value
+  ensure
+    self.current_tenant = old_tenant
+    self.unscoped = old_unscoped
+  end
 end
 
-if defined?(ActionController::Base)
-  ActionController::Base.extend ActsAsTenant::ControllerExtensions
+ActiveSupport.on_load(:active_record) do |base|
+  base.include ActsAsTenant::ModelExtensions
 end
 
-if defined?(ActionController::API)
-  ActionController::API.extend ActsAsTenant::ControllerExtensions
+ActiveSupport.on_load(:action_controller) do |base|
+  base.extend ActsAsTenant::ControllerExtensions
+  base.include ActsAsTenant::TenantHelper
 end
 
-module ActsAsTenant
+ActiveSupport.on_load(:action_view) do |base|
+  base.include ActsAsTenant::TenantHelper
 end
-